@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/denying.d.ts

@@ -0,0 +1,81 @@
+import type { GamePack } from './packs/pack';
+import type { Entity, PlayerId } from './entity';
+import { type HookDef } from './hooks';
+import type { World } from './world';
+/**
+ * Denying, as in a MOBA (features-plan E): a player may tell their units to attack one of their own side's, which
+ * they never do by themselves, once it is low enough on health that the other side would soon have it: the last hit
+ * on it is theirs, not the enemy's. Hooks for `GameModule.hooks`:
+ *
+ *     hooks: [...denying({ below: 0.5 })]
+ *
+ * Only an attack a player orders (`CanAttack.ordered`): units never pick their own side to attack, nor fight back at it
+ *
+ * @beta
+ */
+export interface DenyOptions {
+    /** How low on health, of its most, one of one's own side has to be to be attacked: below half when left out */
+    below?: number;
+    /**
+     * What of one's own side may be attacked, past `below`: units, not heroes nor structures, when left out. A game's own,
+     * to let towers be denied, or only creeps
+     */
+    denies?: (world: World, attacker: Entity, target: Entity) => boolean;
+    /** The id of the hook, to replace or leave out: `deny` when left out */
+    id?: string;
+}
+/**
+ * Whether an attack on one's own side is a deny the rules allow (`DenyOptions`): told to, low enough, of what may be
+ *
+ * @beta
+ */
+export declare function mayDeny(world: World, attacker: Entity, target: Entity, options?: DenyOptions): boolean;
+/**
+ * The hooks of denying (see `DenyOptions`)
+ *
+ * @beta
+ */
+export declare function denying(options?: DenyOptions): HookDef[];
+/**
+ * What a game counts of last hits and denies (`withLastHits`)
+ *
+ * @beta
+ */
+export interface LastHitOptions {
+    /** The rule of denying (`denying`), or `false` for a game that only counts last hits: the engine's when left out */
+    deny?: DenyOptions | false;
+    /**
+     * The part of a unit's experience the enemy heroes near it still get when it is denied, shared as for a kill: a half
+     * when left out (none for a kill by the enemy would be no deny at all; all of it, no point in denying)
+     */
+    experience?: number;
+    /** Which deaths count, as last hits or denies: units, not heroes nor structures, when left out */
+    counts?: (world: World, dead: Entity) => boolean;
+}
+/** Every player's last hits and denies, by player id: saved with the game */
+export declare const counted: import("./components").Component<Record<string, {
+    lastHits: number;
+    denies: number;
+}>, Record<string, {
+    lastHits: number;
+    denies: number;
+}>>;
+/**
+ * A player's last hits (enemy units they gave the killing blow to) and denies (their own side's), as counted
+ * (`withLastHits`)
+ *
+ * @beta
+ */
+export declare function lastHitsOf(world: World, player: PlayerId): {
+    lastHits: number;
+    denies: number;
+};
+/**
+ * A game where last hits and denies count, as in a MOBA: each player's are counted (`lastHitsOf`, saved), a unit
+ * denied gives no bounty (as one killed by its own side never does) and only a part of its experience to the enemy
+ * heroes near it, and its death says so to the screen (`how: 'denied'`, which the client shows over it). With the rule
+ * of denying (`denying`) unless told otherwise
+ *
+ * @beta
+ */
+export declare function withLastHits(options?: LastHitOptions): GamePack;

package/dist/destructibles.d.ts

@@ -0,0 +1,27 @@
+import type { Entity } from './entity';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The destructibles pack's id
+ *
+ * @beta
+ */
+export declare const DESTRUCTIBLES = "core.destructibles";
+/**
+ * What the destructibles pack is made with (`withDestructibles`)
+ *
+ * @beta
+ */
+export interface DestructiblesOptions {
+    /** Whether something is brought down by being attacked when told to, in code: its type's `destructible` when left out */
+    destructible?: (world: World, entity: Entity) => boolean;
+}
+/**
+ * Destructibles, as in classic RTS games: what is `destructible` (`UnitTypeDef.destructible`, a building of the neutral player
+ * placed on the map: rocks, a barricade, a gate to break down) stands in the way until it is brought down, and any unit
+ * whose attack reaches it attacks it when told to (the attack command), never of its own accord, as trees are felled
+ * by what fells them. A gate that opens and shuts is the map's (`setGate`); one that is broken down is a destructible
+ *
+ * @beta
+ */
+export declare function withDestructibles(options?: DestructiblesOptions): GamePack;

package/dist/determinism-BCymQwiE.js

@@ -0,0 +1,518 @@
+import { Cc as xpWorth, Gc as engineMessage, Ju as unitHired, Kn as worthless, Ml as teamMemory, Na as index, Qr as defineHook, Rn as corpseSystem, Ua as string, Wd as distSq, aa as buy, ac as defaultHeroRules, cl as fighting, cr as producers, dc as heroesOf, el as shortOf, fc as learn, ga as shopStock, ia as atShop, ir as leastBusy, ja as id, lc as heroState, li as enqueueRevive, ma as sell, mc as maxLevelOf, oc as grantXp, or as owned, qd as hashText, rc as HEROES, rr as known, sc as heroOf, tl as spend, tr as defineCommand, za as optional } from "./debugCommands-CzjrSm66.js";
+import { o as loadWorld } from "./game-DiJEN-Ks.js";
+import { _t as campHooks, ct as saveWorld, it as encodeSave, rt as decodeSave, xt as campRespawnSystem } from "./coreComponents-syuh2fPG.js";
+//#region src/packs/heroes/hire.ts
+/**
+* Whether someone of a player's stands at a place that hires (`UnitTypeDef.hires`) to hire there: any unit of theirs
+* close enough, as at a shop. The first one found
+*
+* @internal
+*/
+function hirerAt(world, shop, player) {
+	for (const entity of world.index.ownedBy(player)) if (entity.alive && !entity.hidden && entity.def.kind === "unit" && atShop(entity, shop)) return entity;
+}
+/**
+* Why a player cannot hire a unit at a place now, as the message the player is told: none of theirs there, a hero
+* they have already (a hero is hired once), what it costs. Nothing when they can
+*
+* @internal
+*/
+function hireRefusal(world, shop, unit, player) {
+	if (!shop.def.hires?.includes(unit) || !world.registry.units.has(unit)) return engineMessage("cannotDoThat");
+	if (!shop.alive || !shop.operational || world.areEnemies(shop.owner, player)) return engineMessage("cannotDoThat");
+	const def = world.registry.unit(unit);
+	if (def.hero && heroesOf(world, player).some((hero) => hero.def.id === unit)) return engineMessage("alreadyHired", { unit });
+	if (!hirerAt(world, shop, player)) return engineMessage("unitAtShop");
+	const short = shortOf(world.player(player).resources, def.cost);
+	if (short) return engineMessage("notEnough", { resource: short });
+}
+/**
+* Hires a unit at a place that hires for a player: a tavern's hero, a dock's boat. Paid for, and made next to the
+* place, a boat on the water nearest it. The unit, or nothing with the player told why
+*
+* @beta
+*/
+function hire(world, shop, unit, player) {
+	const refusal = hireRefusal(world, shop, unit, player);
+	if (refusal) {
+		world.message(player, refusal);
+		return;
+	}
+	const def = world.registry.unit(unit);
+	spend(world, player, def.cost, "hire", unit);
+	const hired = world.spawn(unit, player, {
+		x: shop.pos.x,
+		z: shop.pos.z + shop.def.radius + def.radius + .5
+	});
+	world.events.emit(unitHired, {
+		shop,
+		unit: hired,
+		player
+	});
+	return hired;
+}
+//#endregion
+//#region src/packs/heroes/commands.ts
+/**
+* The heroes pack's commands: buying and selling at a shop, hiring, putting a point into an ability, bringing a hero
+* back at an altar. Taken by a world whose game has the pack on (`withHeroes`); a game without it refuses them as it
+* does any command it does not know. Their type is among `Command`s, as the pack adds it (`Commands`)
+*/
+/**
+* Buys from a shop, for the hero that is named, or else the one of the player that stands closest to it
+*
+* @internal
+*/
+var buyCommand = defineCommand("buy", {
+	shop: id,
+	item: string,
+	hero: optional(id)
+}, (world, player, command) => {
+	const shop = known(world, player, command.shop);
+	const [buyer] = command.hero === void 0 ? [] : owned(world, player, [command.hero]);
+	if (shop && !world.areEnemies(shop.owner, player)) buy(world, shop, command.item, player, buyer);
+});
+/**
+* Hires a unit at a place that hires, a tavern or a dock: someone of the player's has to be there
+*
+* @internal
+*/
+var hireCommand = defineCommand("hire", {
+	shop: id,
+	unit: string
+}, (world, player, command) => {
+	const shop = known(world, player, command.shop);
+	if (shop) hire(world, shop, command.unit, player);
+});
+/**
+* Gives something a hero carries back at a shop nearby, for a part of its price
+*
+* @internal
+*/
+var sellCommand = defineCommand("sell", {
+	entity: id,
+	item: index
+}, (world, player, command) => {
+	const [seller] = owned(world, player, [command.entity]);
+	if (seller) sell(world, seller, command.item);
+});
+/**
+* Puts a point a hero has to spend into an ability
+*
+* @internal
+*/
+var learnCommand = defineCommand("learn", {
+	entity: id,
+	ability: string
+}, (world, player, command) => {
+	const [hero] = owned(world, player, [command.entity]);
+	if (hero) learn(world, hero, command.ability);
+});
+/** @internal */
+var reviveCommand = defineCommand("revive", {
+	...producers,
+	hero: id
+}, (world, player, command) => {
+	const building = leastBusy(world, player, command, (entity) => !!entity.def.revives);
+	if (building) enqueueRevive(world, building, command.hero);
+});
+/**
+* The commands of the heroes pack (`withHeroes`): buying, hiring, selling, learning, bringing a hero back. A game
+* without the pack refuses them as it does any command it does not know
+*
+* @internal
+*/
+var heroCommands = [
+	buyCommand,
+	hireCommand,
+	sellCommand,
+	learnCommand,
+	reviveCommand
+];
+//#endregion
+//#region src/packs/heroes/making.ts
+/**
+* Makes a unit just made a hero, as its type says (`UnitTypeDef.hero`): level 1, a point to spend, the abilities it can
+* learn (none learned) and the spells it starts with, those it has not got already. What `World.spawn` does for a
+* hero's type, and `morph` for what becomes one
+*
+* @beta
+*/
+function makeHero(world, entity) {
+	const def = entity.def.hero;
+	if (!def) return;
+	entity.set(heroState, {
+		level: 1,
+		xp: 0,
+		points: 1
+	});
+	const add = (id, level) => {
+		if (!entity.abilities.some((state) => state.id === id)) entity.addAbility({
+			id: world.registry.ability(id).id,
+			level,
+			cooldown: 0,
+			autocast: false
+		});
+	};
+	for (const id of def.learns) add(id, 0);
+	for (const id of def.spells ?? []) add(id, 1);
+}
+/** Shares the experience for a kill between the heroes of the killer's side that were around */
+function awardKill(world, dead, killer) {
+	if (!killer || !world.areEnemies(killer.owner, dead.owner)) return;
+	const worth = xpWorth(world, dead);
+	if (worth <= 0) return;
+	const heroes = [];
+	const { xpRange } = world.rules.heroes;
+	for (const player of world.players.values()) {
+		if (!world.areAllies(player.id, killer.owner)) continue;
+		for (const entity of world.index.with(heroState, player.id)) {
+			if (!entity.alive || heroOf(entity).level >= maxLevelOf(world, entity)) continue;
+			if (distSq(entity.pos, dead.pos) <= xpRange * xpRange) heroes.push(entity);
+		}
+	}
+	for (const hero of heroes) grantXp(world, hero, worth / heroes.length, dead);
+}
+//#endregion
+//#region src/packs/heroes/index.ts
+/** A shop's wares, each as many as it stocks; what it stocked already as it was, where it sells it still */
+function stockShop(world, entity) {
+	const sells = entity.def.sells ?? [];
+	const had = entity.get(shopStock);
+	if (!sells.length) {
+		if (had) entity.remove(shopStock);
+		return;
+	}
+	entity.set(shopStock, sells.map((item) => {
+		const kept = had?.find((stock) => stock.item === item);
+		if (kept) return kept;
+		const stock = world.registry.item(item).stock;
+		return {
+			item,
+			count: stock?.max ?? 1,
+			restock: stock?.restock ?? 60
+		};
+	}));
+}
+/** What the pack does as things are made, change type, die and fall: heroes, their experience, shops' wares */
+var heroHooks = [
+	defineHook({
+		hook: "made",
+		id: "hero",
+		run(world, entity) {
+			if (entity.def.hero) makeHero(world, entity);
+			stockShop(world, entity);
+		}
+	}),
+	defineHook({
+		hook: "morphed",
+		id: "hero",
+		run(world, { entity }) {
+			if (entity.def.hero && !entity.has(heroState)) makeHero(world, entity);
+			if (entity.def.sells?.length || entity.has(shopStock)) stockShop(world, entity);
+		}
+	}),
+	defineHook({
+		hook: "death",
+		id: "experience",
+		run(world, { entity, killer }) {
+			if (worthless(entity)) return;
+			awardKill(world, entity, killer);
+		}
+	}),
+	defineHook({
+		hook: "fallenHero",
+		id: "heroesStay",
+		run(_world, event) {
+			if (event.entity.has(heroState)) event.stays = true;
+		}
+	}),
+	...campHooks
+];
+/**
+* A hero's stats grow with its level, as its type says (`UnitTypeDef.hero.growth`): stamped with the level past the
+* first, so that a level set however it is set is added up again
+*/
+var heroGrowth = {
+	id: "heroGrowth",
+	stamp(entity) {
+		if (!entity.def.hero) return 0;
+		const level = heroOf(entity)?.level ?? 1;
+		return level > 1 ? level : 0;
+	},
+	add(_world, entity, sum) {
+		const growth = entity.def.hero?.growth;
+		const hero = growth && heroOf(entity);
+		if (hero && hero.level > 1) sum.add(growth, hero.level - 1);
+	}
+};
+/** Camps come back as the engine's own did: in the clean-up, before the corpses go */
+var campsComeBack = {
+	...campRespawnSystem,
+	before: [corpseSystem.name]
+};
+/**
+* The heroes pack: what makes a game a classic hero RTS, opted into (`GameModule.packs: [withHeroes()]`). Heroes, with
+* their experience, levels, points and abilities to learn, brought back at an altar (`revive`); creeps' camps that guard
+* their ground, sleep at night and come back (`Camp.respawn`); shops that sell (`buy`, `sell`) and places that hire
+* (`hire`). `rules` change its numbers (`HeroRules`: how many heroes, the experience a level takes), the classic RTS numbers for
+* those left out. A game without it pays nothing for any of it: no hero is made of a hero's type, no command of these
+* is taken, no camp is looked at
+*
+* @beta
+*/
+function withHeroes(rules = {}) {
+	for (const key of Object.keys(rules)) if (!(key in defaultHeroRules)) throw new Error(`"${key}" is not a rule of the heroes pack`);
+	return {
+		id: HEROES,
+		options: rules,
+		rules: () => ({ heroes: rules }),
+		commands: [...heroCommands],
+		systems: [campsComeBack],
+		hooks: heroHooks,
+		statParts: [heroGrowth]
+	};
+}
+//#endregion
+//#region src/determinism.ts
+/**
+* Whether a game comes out the same (determinism plan D1): the simulation's state as data and as a hash, and a check
+* that runs a world twice, and on from a save, and says the first tick and the first thing they differ at. What a
+* replay of commands, a save that goes on exactly and a game the same in every browser stand on
+*/
+/**
+* The simulation's state as plain data: its save, which holds all of it, but what each team's screens remember of the
+* map, which is the watchers' (`teamMemory`)
+*
+* @beta
+*/
+function worldState(world) {
+	return decided(saveWorld(world, { reseat: false }), world.registry);
+}
+/**
+* A save as what decides the game: without what each team's screens remember of the map (`teamMemory`: kept in the
+* world for who comes back, written by whoever watches it, and read by nothing that decides), and, with the rules, the
+* components nobody would have made had nobody asked for them (`unasked`)
+*/
+function decided(save, registry) {
+	const { [teamMemory.id]: _memory, ...state } = save.state;
+	const kept = (components) => registry ? unasked(registry, components) : components;
+	return {
+		...save,
+		state: kept(state),
+		players: save.players.map((player) => ({
+			...player,
+			state: kept(player.state)
+		})),
+		entities: save.entities.map((entity) => entity.components ? {
+			...entity,
+			components: kept(entity.components)
+		} : entity)
+	};
+}
+/**
+* Where two saves of a game first differ, as `checkDeterminism` looks (what decides first: the tick, the random state,
+* the players, the entities): the path to it (`entities[id 11].pos.x`) and what each holds there, or nothing when they
+* are the same. What the screens remember of the map, and the hash of the rules they were made with, are left out;
+* with the game's `registry`, so are components that hold what they are made with (a screen asking for one makes it).
+* What a replay that came apart says at its checkpoints (`runReplay`), and `v12 save diff`
+*
+* @beta
+*/
+function saveDifference(a, b, registry) {
+	const ordered = (save) => {
+		const { hash: _rules, ...state } = decided(save, registry);
+		return {
+			...Object.fromEntries(FIRST.map((key) => [key, state[key]])),
+			...state
+		};
+	};
+	return firstDifference(ordered(a), ordered(b));
+}
+/**
+* Components as they would be had nobody asked for one that was not there: one that holds what its component makes
+* when asked for (its `default`) is left out. Asking makes one, and a watcher's screen asks for what it shows (a
+* player's objectives), so a world watched and the same world unwatched differ in that alone
+*/
+function unasked(registry, components) {
+	const kept = {};
+	for (const [id, value] of Object.entries(components)) {
+		const made = registry.component(id)?.default?.();
+		if (made !== void 0 && JSON.stringify(made) === JSON.stringify(value)) continue;
+		kept[id] = value;
+	}
+	return kept;
+}
+/**
+* The simulation's state as a hash: two worlds with the same hash are, to all that is saved of them, the same. Fourteen
+* hex digits (cyrb53, of the save as JSON, but the hash of the rules, which another build of the same code writes
+* otherwise): enough to tell drift, not to stand against someone forging a state
+*
+* @beta
+*/
+var worldHash = (world) => {
+	const { hash: _rules, ...state } = worldState(world);
+	return hashText(canonical(state));
+};
+/**
+* JSON with the keys of every object in order: the same state as text however it was put together (a component a
+* watcher made early comes first in its object, and later where nobody watched)
+*/
+function canonical(value) {
+	return JSON.stringify(value, (_key, each) => {
+		if (!each || typeof each !== "object" || Array.isArray(each)) return each;
+		const sorted = {};
+		for (const key of Object.keys(each).sort()) sorted[key] = each[key];
+		return sorted;
+	});
+}
+/**
+* A quick hash of what a game that came apart differs in first: the tick, the random state, each player's resources,
+* upgrades and supply, and each entity's id, type, owner, place, facing, health, mana, whether it lives, its orders (how
+* many, and the first's kind and target), its buffs (which, and the time left) and its attack's cooldown and swing. Read
+* off the world as it is, with no save: 0.4 ms at 1000 units a side, where `worldHash` takes 66. What a
+* replay of commands keeps every few seconds and checks as it plays (`recordCommands`), and what `checkDeterminism`
+* compares every tick, for the tick a game came apart at; what it leaves out (components, areas, the fog) the whole
+* state, compared every so often, has
+*
+* @beta
+*/
+function worldFingerprint(world) {
+	const values = [world.tick, world.rng.save()];
+	for (const player of world.players.values()) {
+		values.push(player.id, player.supplyUsed, player.supplyCap);
+		for (const key of Object.keys(player.resources).sort()) values.push(player.resources[key] ?? 0);
+		for (const [upgrade, level] of player.upgrades) values.push(wordOf(upgrade), level);
+	}
+	for (const entity of world.entities.values()) {
+		values.push(entity.id, wordOf(entity.def.id), entity.owner, entity.pos.x, entity.pos.z, entity.facing, entity.hp, entity.mana, entity.alive ? 1 : 0);
+		const order = entity.orders[0];
+		values.push(entity.orders.length, order ? wordOf(order.type) : 0, order?.init.target ?? 0);
+		values.push(entity.buffs.length);
+		for (const buff of entity.buffs) values.push(wordOf(buff.id), buff.remaining);
+		if (entity.get(fighting)) values.push(entity.get(fighting).cooldown, entity.get(fighting).swing);
+	}
+	return hashWords(new Uint32Array(Float64Array.from(values).buffer));
+}
+/** A short text as a number, for the fingerprint: FNV-1a of its characters */
+function wordOf(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+	return h >>> 0;
+}
+/** cyrb53 of 32-bit words: the bits of numbers, hashed as they are */
+function hashWords(words) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (const word of words) {
+		h1 = Math.imul(h1 ^ word, 2654435761);
+		h2 = Math.imul(h2 ^ word, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
+}
+/**
+* Where two states first differ: the path to it (`entities[id 11].pos.x`) and what each holds there. Nothing when they
+* are the same. Lists of things with an `id` are named by it, the rest by their place
+*
+* @beta
+*/
+function firstDifference(a, b, path = "") {
+	if (Object.is(a, b)) return void 0;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) !== Array.isArray(b)) return {
+		path,
+		a,
+		b
+	};
+	if (Array.isArray(a) && Array.isArray(b)) {
+		for (let i = 0; i < Math.max(a.length, b.length); i++) {
+			const each = a[i] ?? b[i];
+			const named = each && typeof each === "object" && "id" in each ? `[id ${String(each.id)}]` : `[${i}]`;
+			const found = firstDifference(a[i], b[i], `${path}${named}`);
+			if (found) return found;
+		}
+		return;
+	}
+	const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+	for (const key of keys) {
+		const found = firstDifference(a[key], b[key], path ? `${path}.${key}` : key);
+		if (found) return found;
+	}
+}
+/**
+* Makes a world twice with `make` (the same seed, the same commands given in it, as a replay would) and runs them side
+* by side, comparing their fingerprints every tick and their states (and the order each player's entities are filed
+* in) every `every` ticks; with `from`, a third is saved at that tick and a fourth loaded
+* from the save, and the two run on side by side. Says, for each, the first tick and thing it differs at, or that it does not. A test of a game's
+* own systems: one that reads `Math.random`, the clock, or the order of something unordered is found here
+*
+*     const report = await checkDeterminism(() => makeMyGame(1), { ticks: 1800, from: 300, game: rules })
+*     expect(report).toEqual({ twice: null, fromSave: null })
+*
+* @beta
+*/
+async function checkDeterminism(make, options) {
+	const { ticks, every = 30, from } = options;
+	if (from !== void 0 && !options.game) throw new Error("checkDeterminism: a check from a save needs the game to load it with (game)");
+	const first = await make();
+	const second = await make();
+	const saved = from === void 0 ? void 0 : await make();
+	let loaded;
+	const report = {
+		twice: null,
+		...from !== void 0 && { fromSave: null }
+	};
+	try {
+		for (let tick = 1; tick <= ticks; tick++) {
+			first.step();
+			if (!report.twice) second.step();
+			if (saved && !report.fromSave) {
+				saved.step();
+				loaded?.step();
+				if (saved.tick === from) loaded = await loadWorld(decodeSave(encodeSave(saveWorld(saved))), { game: options.game });
+			}
+			const whole = tick % every === 0;
+			if (!report.twice && (whole || worldFingerprint(first) !== worldFingerprint(second))) report.twice = apartAt(first.tick, compared(first), compared(second));
+			if (loaded && !report.fromSave && saved.tick > from && (whole || worldFingerprint(saved) !== worldFingerprint(loaded))) report.fromSave = apartAt(saved.tick, compared(saved), compared(loaded));
+			if (report.twice && (from === void 0 || report.fromSave)) break;
+		}
+	} finally {
+		first.dispose();
+		second.dispose();
+		saved?.dispose();
+		loaded?.dispose();
+	}
+	return report;
+}
+var compared = (world) => ({
+	...worldState(world),
+	owned: Object.fromEntries([...world.players.keys()].map((player) => [player, [...world.index.ownedBy(player)].map((entity) => entity.id)]))
+});
+/**
+* What is looked at first: what is decided (the random state, the players, the entities, the order they are filed in)
+* before what follows from it (the fog, which units see), so that what is said is where it began
+*/
+var FIRST = [
+	"tick",
+	"rng",
+	"players",
+	"entities",
+	"owned",
+	"actors"
+];
+var apartAt = (tick, a, b) => {
+	const ordered = (state) => ({
+		...Object.fromEntries(FIRST.map((key) => [key, state[key]])),
+		...state
+	});
+	const found = firstDifference(ordered(a), ordered(b));
+	return found ? {
+		tick,
+		...found
+	} : null;
+};
+//#endregion
+export { hirerAt as _, worldHash as a, makeHero as c, hireCommand as d, learnCommand as f, hireRefusal as g, hire as h, worldFingerprint as i, buyCommand as l, sellCommand as m, firstDifference as n, worldState as o, reviveCommand as p, saveDifference as r, withHeroes as s, checkDeterminism as t, heroCommands as u };
+
+//# sourceMappingURL=determinism-BCymQwiE.js.map