@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/messages.d.ts

@@ -0,0 +1,150 @@
+/**
+ * What the simulation tells a player, like "Not enough gold", is a key and some params, never words. The words are
+ * the business of the player's screen: the client has English for the engine's keys, and a game's view gives its own
+ * (`GameView.hud.messages`) or other words for the engine's. That keeps the engine free of any one language, and lets
+ * a game say "build more farms" where the engine only knows about supply.
+ *
+ * Params that name something are ids (a resource, a unit type, an upgrade), for the screen to find the name of.
+ *
+ * @beta
+ */
+export interface Message {
+    key: string;
+    params?: MessageParams;
+}
+/** @beta */
+export type MessageParams = Record<string, string | number | string[]>;
+/**
+ * A message, or a bare key for one without params. What hooks give as the reason something is called off
+ *
+ * @beta
+ */
+export type MessageRef = Message | string;
+/** @beta */
+export declare const toMessage: (message: MessageRef) => Message;
+/**
+ * The messages the engine sends, and their params. The client has words for each of these.
+ * A game can send keys of its own as well.
+ *
+ * @beta
+ */
+export interface EngineMessages {
+    /** Cannot afford something: `resource` is the id of what is short */
+    notEnough: {
+        resource: string;
+    };
+    /** A prefab asked for by a name the game has not (`debug.spawnPrefab`) */
+    unknownPrefab: {
+        prefab: string;
+    };
+    /** The unit types the player still needs to build to make or research something, by id */
+    requires: {
+        units: string[];
+    };
+    queueFull: {};
+    alreadyHaveHero: {};
+    tooManyHeroes: {};
+    /** Out of supply, and could build more of what provides it. `pool` for one of the game's own (`GameRules.supply.pools`) */
+    supplyBlocked: {
+        pool?: string;
+    };
+    /** Out of supply, and at the most anyone can have (`GameRules.supply.max`, a pool's `max`) */
+    supplyLimit: {
+        pool?: string;
+    };
+    alreadyResearching: {};
+    researchDone: {
+        upgrade: string;
+    };
+    /** `unit` is the id of the hero's type */
+    heroLevel: {
+        unit: string;
+        level: number;
+    };
+    defeated: {};
+    /** Another player gave up. `player` is their name */
+    surrendered: {
+        player: string;
+    };
+    /** Every pause of the player's is used */
+    noPausesLeft: {};
+    cannotBuildThere: {};
+    /** The navigation has no room for another building in the way (`RecastNavigationOptions.maxObstacles`) */
+    tooManyBuildings: {};
+    cannotReachSite: {};
+    cannotReach: {};
+    /** A worker with something to bring back and nowhere to bring it. `resource` is its id */
+    nowhereToReturn: {
+        resource: string;
+    };
+    cannotGather: {
+        resource: string;
+    };
+    buildOnResource: {
+        resource: string;
+    };
+    inventoryFull: {};
+    theirInventoryFull: {};
+    outOfStock: {};
+    /** Buying needs one of the player's heroes at the shop, with a free slot */
+    heroAtShop: {};
+    /** Hiring needs one of the player's units at the place that hires */
+    unitAtShop: {};
+    /** A hero is hired once: the player has it already. `unit` is its type */
+    alreadyHired: {
+        unit: string;
+    };
+    noShopNear: {};
+    cannotDoThat: {};
+    notReady: {};
+    notEnoughMana: {};
+    notEnoughHealth: {};
+    silenced: {};
+    /** An ability used on something it is not for */
+    cannotTargetThat: {};
+    cannotTargetFriends: {};
+    cannotTargetSelf: {};
+    cannotTargetAir: {};
+    mustTargetAir: {};
+    mustTargetHero: {};
+    /** An ability used on what is immune to spells */
+    targetSpellImmune: {};
+    /** Pinged too often: the rest go nowhere for a moment */
+    tooManyPings: {};
+    /** Said too much too quickly: the rest goes nowhere for a moment */
+    tooManyLines: {};
+    /** Sent commands faster than the game takes them (a server's rate, `World.commandLimit`): the rest went nowhere */
+    tooManyCommands: {};
+    /** Resources given to someone who is not an ally */
+    notAnAlly: {};
+    /** Resources given to an ally, and received from one (see `give`) */
+    sent: {
+        amount: number;
+        resource: string;
+        player: string;
+    };
+    received: {
+        amount: number;
+        resource: string;
+        player: string;
+    };
+    /** One resource traded for another at a rate (see `exchange`): `amount` of `resource` went, `received` of `for` came */
+    exchanged: {
+        amount: number;
+        resource: string;
+        received: number;
+        for: string;
+    };
+    /** A field of a definition the game does not let be changed, or a value it does not take (`debug.redefine`) */
+    dataRefused: {
+        why: string;
+    };
+}
+/**
+ * A message of the engine's own, with its params checked
+ *
+ * @beta
+ */
+export declare const engineMessage: <K extends keyof EngineMessages>(key: K, ...params: {} extends EngineMessages[K] ? [] | [EngineMessages[K]] : [EngineMessages[K]]) => Message;
+/** A message, to whom it is for */
+export declare const toldMessage: import("./replication").ReplicatedEvent;

package/dist/missionRules-C-bGxm0Q.js

@@ -0,0 +1,523 @@
+import { Nd as defineComponent, Qr as defineHook, Sr as defeat, To as defineTimer, lo as playCinematic, mu as gameOver, td as defineEvent } from "./debugCommands-CzjrSm66.js";
+//#region src/mapObjectives.ts
+/**
+* The map objectives pack's id
+*
+* @beta
+*/
+var MAP_OBJECTIVES = "core.mapObjectives";
+/**
+* The key of the map's data its objectives are kept under (`GameMap.data.objectives`)
+*
+* @beta
+*/
+var MAP_OBJECTIVES_KEY = "objectives";
+/** The words of an objective as a file may hold them: a key, or a key with params */
+var isWords = (text) => typeof text === "string" ? text.trim() !== "" : typeof text === "object" && text !== null && typeof text.key === "string" && text.key !== "";
+/**
+* The objectives a map gives (`GameMap.data.objectives`), in the order it gives them: none for a map with none. What is
+* kept there and is no objective (no id, no words) is left out, so that a file changed by hand breaks no rule that reads
+* it; the map's checks say so (`mapObjectives`)
+*
+* @beta
+*/
+function mapObjectivesOf(map) {
+	const kept = map.data[MAP_OBJECTIVES_KEY];
+	if (!Array.isArray(kept)) return [];
+	return kept.filter((each) => typeof each === "object" && each !== null && typeof each.id === "string" && each.id !== "" && isWords(each.text)).map((each) => ({
+		id: each.id,
+		text: each.text,
+		...each.detail !== void 0 && isWords(each.detail) && { detail: each.detail },
+		...each.required !== void 0 && { required: each.required !== false },
+		at: each.at === "rule" ? "rule" : "start"
+	}));
+}
+/**
+* Who is given a map's objective when the rules do not say (`giveMapObjective`): the map's players a person plays, not
+* those it says the computer plays or nobody does (`MapPlayer.controller`), in the order of their ids
+*
+* @beta
+*/
+function mapObjectivePlayers(world) {
+	return [...world.players.values()].filter((player) => !player.neutral && !player.creeps).filter((player) => {
+		const controller = world.map.player(player.id)?.controller;
+		return controller !== "computer" && controller !== "nobody";
+	}).map((player) => player.id).sort((a, b) => a - b);
+}
+/**
+* Gives players an objective of the map's, by its id (`MapObjective`): those given by a rule (`at: 'rule'`), when the
+* rules say. To every player a person plays when `players` is left out (`mapObjectivePlayers`); a player who has it
+* already keeps theirs. Its words' params and its progress go with it, as `world.objectives.add`. Throws for an id the
+* map does not have: an id in the code that is not on the map is a mistake
+*
+* @beta
+*/
+function giveMapObjective(world, id, options = {}) {
+	const def = mapObjectivesOf(world.map).find((objective) => objective.id === id);
+	if (!def) throw new Error(`The map${world.map.name ? ` "${world.map.name}"` : ""} has no objective "${id}"`);
+	const { at: _at, ...objective } = def;
+	const given = [];
+	for (const player of options.players ?? mapObjectivePlayers(world)) {
+		if (world.objectives.has(player, id)) continue;
+		given.push(world.objectives.add(player, objective, {
+			params: options.params,
+			progress: options.progress
+		}));
+	}
+	return given;
+}
+/**
+* What is wrong with a map's objectives (`GameMap.data.objectives`): one with no id or with another's, one with no
+* words, a list that is not one. Each a click away in the Objectives panel
+*
+* @beta
+*/
+function checkMapObjectives(map) {
+	const kept = map.data[MAP_OBJECTIVES_KEY];
+	if (kept === void 0) return [];
+	if (!Array.isArray(kept)) return [{
+		message: "The map’s objectives are not a list",
+		error: true,
+		rule: "objectives"
+	}];
+	const problems = [];
+	const seen = /* @__PURE__ */ new Set();
+	kept.forEach((each, index) => {
+		const id = typeof each?.id === "string" ? each.id : "";
+		const reveal = {
+			panel: "objectives",
+			entry: id || String(index)
+		};
+		if (!id) problems.push({
+			message: `Objective ${index + 1} has no id`,
+			error: true,
+			rule: "objective-id",
+			reveal
+		});
+		else if (seen.has(id)) problems.push({
+			message: `Two objectives have the id "${id}"`,
+			error: true,
+			rule: "objective-id",
+			reveal
+		});
+		seen.add(id);
+		if (!isWords(each?.text)) problems.push({
+			message: `The objective "${id || index + 1}" has no words`,
+			error: true,
+			rule: "objective-text",
+			reveal
+		});
+	});
+	return problems;
+}
+/**
+* Objectives as data on the map (campaign plan EQ3): a map's objectives (`MapObjective`, kept in `GameMap.data.objectives`,
+* written by the editor's Objectives panel) given at the start to every player a person plays, as the world is made
+* from the map; those given by a rule wait for the rules (`giveMapObjective(world, id)`). Done and failed as any
+* objective is (`world.objectives.complete`, `fail`); a game that is won by them has `objectiveVictory` as its
+* `victory`. The map's checks say what is wrong with them (`checkMapObjectives`)
+*
+* @beta
+*/
+function mapObjectives() {
+	return {
+		id: MAP_OBJECTIVES,
+		hooks: [defineHook({
+			hook: "mapStart",
+			id: MAP_OBJECTIVES,
+			run(world) {
+				for (const objective of mapObjectivesOf(world.map)) if (objective.at === "start") giveMapObjective(world, objective.id);
+			}
+		})],
+		check: (map) => checkMapObjectives(map)
+	};
+}
+//#endregion
+//#region src/missionRules.ts
+/**
+* The mission rules pack's id
+*
+* @beta
+*/
+var MISSION_RULES = "core.missionRules";
+/**
+* The key of the map's data its rules are kept under (`GameMap.data.rules`)
+*
+* @beta
+*/
+var MAP_RULES_KEY = "rules";
+/**
+* What the mission rules remember: in the world's state, so that a save has it
+*
+* @internal
+*/
+var missionRulesState = defineComponent("core.missionRules", { default: () => ({
+	rules: {},
+	told: [],
+	timers: {}
+}) });
+/**
+* A mission rule fired: its id. For a pack of the game's that does what the rules cannot
+*
+* @beta
+*/
+var ruleFired = defineEvent("core.ruleFired");
+var ACTIONS = [
+	"objective",
+	"say",
+	"cinematic",
+	"spawn",
+	"tell",
+	"relation",
+	"timer",
+	"win",
+	"lose"
+];
+/** The form of an action, by its one key: none for data that is no action */
+var actionKind = (action) => {
+	if (typeof action !== "object" || action === null) return void 0;
+	const keys = Object.keys(action);
+	return keys.length === 1 && ACTIONS.includes(keys[0]) ? keys[0] : void 0;
+};
+/** Whether data is a rule's condition: an object of one form */
+var isCondition = (when) => typeof when === "object" && when !== null && Object.keys(when).length > 0;
+/**
+* The rules a map keeps (`GameMap.data.rules`), in their order: none for a map with none. What is kept there and is no
+* rule (no id, no condition) is left out, so that a file changed by hand breaks no game that reads it; the map's checks
+* say so (`checkMissionRules`). Actions that are of no form the pack knows are left out of a rule the same way
+*
+* @beta
+*/
+function missionRulesOf(map) {
+	const kept = map.data[MAP_RULES_KEY];
+	if (!Array.isArray(kept)) return [];
+	return kept.filter((each) => typeof each === "object" && each !== null && typeof each.id === "string" && each.id !== "" && isCondition(each.when)).map((each) => ({
+		id: each.id,
+		when: each.when,
+		do: Array.isArray(each.do) ? each.do.filter((action) => actionKind(action) !== void 0) : [],
+		...each.once !== void 0 && { once: each.once === true },
+		...typeof each.every === "number" && each.every > 0 && { every: each.every },
+		...typeof each.as === "number" && { as: each.as }
+	}));
+}
+/**
+* Tells the mission rules a word, as the game's code does for what the rules cannot know on their own (the boss fell,
+* the player chose): a rule `when: { told: word }` fires at the next check, and the word is heard no more after it.
+* What a rule's timer does as it goes off
+*
+* @beta
+*/
+function tellRules(world, word, data) {
+	world.state(missionRulesState).told.push({
+		word,
+		...data !== void 0 && { data },
+		tick: world.tick
+	});
+}
+/**
+* What a mission rule is now (`MissionRuleState`): none for a rule the world has not, or has not checked yet
+*
+* @beta
+*/
+function missionRuleState(world, id) {
+	if (!world.states.has(missionRulesState)) return void 0;
+	const kept = world.state(missionRulesState).rules[id];
+	return kept && {
+		holds: !!kept.was,
+		count: kept.count,
+		...kept.fired !== void 0 && { fired: kept.fired }
+	};
+}
+/** The names of the regions a condition asks about, wherever it is in it */
+function regionsNamed(when, out = []) {
+	if (typeof when !== "object" || when === null) return out;
+	const condition = when;
+	if ("region" in condition && typeof condition.region?.name === "string") out.push(condition.region.name);
+	for (const key of ["all", "any"]) if (Array.isArray(condition[key])) for (const each of condition[key]) regionsNamed(each, out);
+	if ("not" in condition) regionsNamed(condition.not, out);
+	return out;
+}
+/**
+* What is wrong with a map's rules (`GameMap.data.rules`): one with no id or with another's, one with no condition, an
+* action of no form the pack knows, a condition or an action naming what the map or the game has not (a region, an
+* objective, a prefab, a player). Each a click away in the Rules panel
+*
+* @beta
+*/
+function checkMissionRules(map, registry) {
+	const kept = map.data[MAP_RULES_KEY];
+	if (kept === void 0) return [];
+	if (!Array.isArray(kept)) return [{
+		message: "The map’s rules are not a list",
+		error: true,
+		rule: "rules"
+	}];
+	const problems = [];
+	const seen = /* @__PURE__ */ new Set();
+	const regions = new Set(map.regions.map((region) => region.name));
+	const objectives = new Set(mapObjectivesOf(map).map((objective) => objective.id));
+	const players = new Set(map.players.map((player) => player.id));
+	kept.forEach((each, index) => {
+		const id = typeof each?.id === "string" ? each.id : "";
+		const name = id || String(index + 1);
+		const reveal = {
+			panel: "rules",
+			entry: id || String(index)
+		};
+		const problem = (message, rule, error = true) => problems.push({
+			message,
+			error,
+			rule,
+			reveal
+		});
+		if (!id) problem(`Rule ${index + 1} has no id`, "rule-id");
+		else if (seen.has(id)) problem(`Two rules have the id "${id}"`, "rule-id");
+		seen.add(id);
+		if (!isCondition(each?.when)) problem(`The rule "${name}" has no condition`, "rule-when");
+		else for (const region of regionsNamed(each.when)) if (!regions.has(region)) problem(`The rule "${name}" asks about a region "${region}" the map has not`, "rule-name");
+		if (each?.as !== void 0 && !players.has(each.as)) problem(`The rule "${name}" is asked as a player ${each.as} the map has not`, "rule-name");
+		const actions = Array.isArray(each?.do) ? each.do : [];
+		if (!actions.length) problem(`The rule "${name}" does nothing`, "rule-action", false);
+		for (const action of actions) {
+			const kind = actionKind(action);
+			if (!kind) {
+				problem(`The rule "${name}" has an action of no form the rules know (${Object.keys(action ?? {}).join(", ") || "nothing"})`, "rule-action");
+				continue;
+			}
+			const data = action[kind];
+			const named = (player, what) => {
+				if (typeof player === "number" && !players.has(player)) problem(`The rule "${name}" ${what} a player ${player} the map has not`, "rule-name");
+			};
+			if (kind === "objective" && !objectives.has(String(data?.id ?? ""))) problem(`The rule "${name}" names an objective "${data?.id ?? ""}" the map has not`, "rule-name");
+			if (kind === "spawn" && registry && !registry.prefabs.has(String(data?.prefab ?? ""))) problem(`The rule "${name}" spawns a prefab "${data?.prefab ?? ""}" the game has not`, "rule-name");
+			if (kind === "spawn" && typeof data?.at === "string" && !placeNamed(map, data.at)) problem(`The rule "${name}" spawns at "${data.at}", which the map has not`, "rule-name");
+			if (kind === "spawn") named(data?.owner, "spawns for");
+			if (kind === "tell") named(data?.computer, "tells");
+			if (kind === "relation") {
+				named(data?.a, "sets");
+				named(data?.b, "sets");
+			}
+			if (typeof data === "object" && data !== null && Array.isArray(data.to)) for (const player of data.to) named(player, "is for");
+		}
+	});
+	return problems;
+}
+/** Whether a map has a place of this name: a point, a region, or something placed and named */
+var placeNamed = (map, name) => map.points.some((point) => point.name === name) || map.regions.some((region) => region.name === name) || map.objects.some((object) => object.name === name);
+/** Where a place is in the world: a point or a region of the map by name, a named thing, or the point given */
+function placeOf(world, at) {
+	if (typeof at !== "string") return {
+		x: at.x,
+		z: at.z
+	};
+	const point = world.map.points.find((each) => each.name === at);
+	if (point) return {
+		x: point.x,
+		z: point.z
+	};
+	const region = world.map.regions.find((each) => each.name === at);
+	if (region) return {
+		x: region.shape.x,
+		z: region.shape.z
+	};
+	const named = world.named(at);
+	return named && {
+		x: named.pos.x,
+		z: named.pos.z
+	};
+}
+/**
+* The players a rule's actions are for when they say none: the people, else everyone who can win or lose
+*
+* @internal
+*/
+function rulePlayers(world) {
+	const people = mapObjectivePlayers(world);
+	if (people.length) return people;
+	return [...world.players.values()].filter((player) => !player.neutral && !player.creeps).map((player) => player.id).sort((a, b) => a - b);
+}
+/**
+* The timer of a rule's `timer` action: as it goes off, the rules are told its id, and the screens stop counting it
+*
+* @internal
+*/
+var ruleTimer = defineTimer("core.missionRules.timer", (world, { word, to }, timer) => {
+	const state = world.state(missionRulesState);
+	if (state.timers[word] === timer.id) delete state.timers[word];
+	for (const player of to ?? []) world.timers.hide(player, timer.id);
+	tellRules(world, word);
+});
+/**
+* Does one action of a rule, now
+*
+* @internal
+*/
+function doMissionAction(world, rule, action) {
+	const warn = (line) => world.log.warn("rules", `the rule "${rule.id}" ${line}`);
+	const people = rulePlayers(world);
+	if ("objective" in action) {
+		const { id, do: what = "give", to = people, reason } = action.objective;
+		if (what === "give") {
+			if (!mapObjectivesOf(world.map).some((objective) => objective.id === id)) return warn(`gives an objective "${id}" the map has not`);
+			giveMapObjective(world, id, { players: to });
+		} else for (const player of to) if (world.objectives.has(player, id)) what === "complete" ? world.objectives.complete(player, id) : world.objectives.fail(player, id, reason);
+	} else if ("say" in action) {
+		const { speaker, text, seconds, to = people } = action.say;
+		world.dialog.say(to, {
+			speaker,
+			text,
+			...seconds !== void 0 && { seconds }
+		});
+	} else if ("cinematic" in action) {
+		const { id, to, hold, skippable } = action.cinematic;
+		playCinematic(world, id, {
+			to: to ?? "everyone",
+			hold,
+			skippable
+		});
+	} else if ("spawn" in action) {
+		const { prefab, at, owner, facing } = action.spawn;
+		if (!world.registry.prefabs.has(prefab)) return warn(`spawns a prefab "${prefab}" the game has not`);
+		const place = placeOf(world, at);
+		if (!place) return warn(`spawns at "${String(at)}", which the map has not`);
+		world.spawnPrefab(prefab, {
+			at: place,
+			owner,
+			facing
+		});
+	} else if ("tell" in action) {
+		const { computer, word, data } = action.tell;
+		if (!world.computers.tell(computer, word, data)) warn(`tells player ${computer} "${word}", and the computer does not play them`);
+	} else if ("relation" in action) {
+		const { a, b, how } = action.relation;
+		world.sides.setRelation(a, b, how);
+	} else if ("timer" in action) {
+		const { id, seconds, label, to = people } = action.timer;
+		const state = world.state(missionRulesState);
+		if (state.timers[id] !== void 0) world.timers.cancel(state.timers[id]);
+		const shown = label === void 0 ? [] : to;
+		const timer = world.timers.after(seconds, ruleTimer, {
+			word: id,
+			...shown.length && { to: shown }
+		});
+		state.timers[id] = timer;
+		for (const player of shown) world.timers.show(player, timer, { label });
+	} else if ("win" in action) {
+		const to = action.win === true ? people : action.win.to ?? people;
+		if (world.winner !== null || !to.length) return;
+		const team = world.player(to[0]).team;
+		world.winner = team;
+		world.events.emit(gameOver, { winner: team });
+	} else if ("lose" in action) {
+		const to = action.lose === true ? people : action.lose.to ?? people;
+		for (const player of to) if (!world.player(player).defeated) defeat(world, player);
+	}
+}
+/**
+* The system that runs the rules: once a second, each watcher reads the picture, the words told since the last check
+* are heard, and each rule's condition is asked and its actions done as it turns true. The watchers' memory is the
+* system's to save
+*/
+function rulesSystem(world, own, watch) {
+	let read;
+	const rulesOf = () => {
+		if (read) return read;
+		read = [];
+		const ids = /* @__PURE__ */ new Set();
+		for (const rule of [...missionRulesOf(world.map), ...own]) {
+			if (ids.has(rule.id)) {
+				world.log.warn("rules", `two rules are called "${rule.id}": the second is left out`);
+				continue;
+			}
+			ids.add(rule.id);
+			read.push(rule);
+		}
+		return read;
+	};
+	const watchers = /* @__PURE__ */ new Map();
+	let restored;
+	const defaultPlayer = () => rulePlayers(world)[0];
+	const watcher = (player) => {
+		let made = watchers.get(player);
+		if (made) return made;
+		if (!world.players.has(player)) return void 0;
+		made = watch(world, player);
+		const memory = restored?.[player];
+		if (memory !== void 0) made.restore(memory);
+		watchers.set(player, made);
+		return made;
+	};
+	return {
+		name: "missionRules",
+		phase: "cleanup",
+		every: Math.max(1, Math.round(world.tickRate)),
+		offset: 3,
+		update() {
+			const rules = rulesOf();
+			if (!rules.length) return;
+			const state = world.state(missionRulesState);
+			const told = state.told.splice(0);
+			const asked = /* @__PURE__ */ new Set();
+			for (const rule of rules) {
+				const player = rule.as ?? defaultPlayer();
+				if (player !== void 0) asked.add(player);
+			}
+			for (const player of asked) {
+				const made = watcher(player);
+				if (!made) continue;
+				made.think();
+				for (const word of told) made.tell(word.word, word.data, word.tick);
+			}
+			for (const rule of rules) {
+				const kept = state.rules[rule.id] ??= { count: 0 };
+				if (rule.once && kept.count > 0) continue;
+				const player = rule.as ?? defaultPlayer();
+				const made = player === void 0 ? void 0 : watcher(player);
+				if (!made) {
+					if (kept.was === void 0) world.log.warn("rules", `the rule "${rule.id}" is asked as a player ${player} the world has not: it never fires`);
+					kept.was = false;
+					continue;
+				}
+				const holds = made.ask(rule.when);
+				const turned = holds && !kept.was;
+				kept.was = holds;
+				if (!holds) continue;
+				const again = rule.every !== void 0 && kept.fired !== void 0 && world.tick - kept.fired >= Math.round(rule.every * world.tickRate);
+				if (!turned && !again) continue;
+				kept.fired = world.tick;
+				kept.count++;
+				world.log.info("rules", `the rule "${rule.id}" fires`);
+				world.events.emit(ruleFired, { rule: rule.id });
+				for (const action of rule.do) doMissionAction(world, rule, action);
+			}
+			for (const made of watchers.values()) for (const word of new Set(told.map((each) => each.word))) made.takeTold(word);
+		},
+		save: () => ({ watchers: Object.fromEntries([...watchers].map(([player, made]) => [player, made.save()])) }),
+		restore: (_world, data) => {
+			restored = data?.watchers;
+			for (const [player, made] of watchers) if (restored?.[player] !== void 0) made.restore(restored[player]);
+		}
+	};
+}
+/**
+* The mission rules pack, given what asks a rule's condition (`RulesWatcher`): what `missionRules` of `@v12-engine/engine/ai`
+* makes, with a watcher of the computer players' kit. The map's rules and `rules` of the code's, run as the game plays
+*
+* @internal
+*/
+function missionRulesPack(options) {
+	const own = options.rules ?? [];
+	return {
+		id: MISSION_RULES,
+		components: [missionRulesState],
+		events: [ruleFired],
+		timers: [ruleTimer],
+		systems: [(world) => rulesSystem(world, own, options.watch)],
+		check: (map, registry) => checkMissionRules(map, registry),
+		...own.length && { options: { rules: own.map((rule) => rule.id) } }
+	};
+}
+//#endregion
+export { missionRulesOf as a, tellRules as c, checkMapObjectives as d, giveMapObjective as f, mapObjectivesOf as h, missionRuleState as i, MAP_OBJECTIVES as l, mapObjectives as m, MISSION_RULES as n, missionRulesPack as o, mapObjectivePlayers as p, checkMissionRules as r, ruleFired as s, MAP_RULES_KEY as t, MAP_OBJECTIVES_KEY as u };
+
+//# sourceMappingURL=missionRules-C-bGxm0Q.js.map