@v12-engine/engine 0.1.1 → 0.4.0

package/dist/game.js

@@ -0,0 +1,834 @@
+import { spawnStartingBase } from "./start.js";
+import { noStats } from "./defs.js";
+import { inventorySlots } from "./inventory.js";
+import { eventsPart, snapshotField } from "./replication.js";
+import { constructionSystem, toldBuilt, toldConstructionCancelled, toldConstructionStarted, toldWork } from "./systems/construction.js";
+import { toldMessage } from "./messages.js";
+import { productionQueue, toldUpgradeCancelled } from "./systems/productionQueue.js";
+import { toldLevelUp, toldRevived, toldXp } from "./hero.js";
+import { toldStrike } from "./abilities/land.js";
+import { toldBuffOff, toldBuffOn } from "./abilities/buffs.js";
+import { movementSystem } from "./systems/movement.js";
+import { combatSystem } from "./systems/combat.js";
+import { missilesPart, toldMana, toldMissileHit } from "./abilities/effects.js";
+import { areaSystem } from "./areas.js";
+import { toldRustle } from "./concealment.js";
+import "./map/types.js";
+import { fieldValues, mapCampData, mapFields, mapPlayerData, mapRegionData } from "./mapFields.js";
+import { mapInfo } from "./names.js";
+import { toldGust } from "./foliage.js";
+import { hasGroundSpeeds, navigationSpeedOn } from "./groundSpeed.js";
+import { overSettings, resolveSettings } from "./rules.js";
+import { timerSystem } from "./timers.js";
+import { sequenceSystem } from "./sequences.js";
+import { regionCinematic, toldCinematic, toldCinematicCue } from "./cinematics.js";
+import { toldCast, toldCastCancelled, toldChannelEnded, toldChannelStarted, toldWindup } from "./abilities/castTold.js";
+import { toldCells, toldCellsSeen } from "./cellLayers.js";
+import { cameraPart, toldCamera } from "./cameraOrders.js";
+import { coreFormations } from "./formation.js";
+import { itemTier, itemsPart, toldPicked } from "./items.js";
+import { castOrder } from "./orders/cast.js";
+import { gathering, harvestOrder, returnOrder } from "./orders/harvest.js";
+import { checkRaces, raceHooks, raceResources } from "./races.js";
+import { toldMorphed } from "./tech.js";
+import { productionSystem, toldResearched, toldTrained, toldUpgradeStarted } from "./systems/production.js";
+import { buildOrder, constructOrder, repairOrder } from "./orders/build.js";
+import { boardOrder, cargo, loadOrder, transportSank, transportSystem, unloadOrder } from "./transport.js";
+import { toldChat, toldPing } from "./talk.js";
+import { lastTeamStanding, outcomePart } from "./systems/victory.js";
+import { orderSystem } from "./systems/orders.js";
+import { coreCommands, toldCommand } from "./commands.js";
+import { toldLine, toldLineEnded } from "./dialog.js";
+import { toldFx, toldFxStopped } from "./effects.js";
+import { corpseSystem, corpsesPart, summonEffects } from "./summons.js";
+import { formSystem } from "./forms.js";
+import { coreHooks, toldBounty } from "./features.js";
+import { dispelEffects } from "./abilities/dispel.js";
+import { coreEffects } from "./abilities/effects/core.js";
+import { layData, toldRedefined } from "./gameData.js";
+import { fogSystem, revealsPart } from "./systems/fog.js";
+import { toldCrit, toldDamage, toldDeath, toldHeal } from "./life.js";
+import "./tiles.js";
+import { toldEnvironment } from "./map/look.js";
+import { toldObjective } from "./objectives.js";
+import { MissingGround, cloneTerrain, groundOf, startedOn, startingTerrain } from "./ground.js";
+import { drawFromGroup, dropFromTable } from "./randomGroups.js";
+import { giveMapOrders, spawnMapObject } from "./mapObjects.js";
+import { debugCommands, debugPart, redefineCommand, toldGround } from "./debugCommands.js";
+import { hourPart } from "./clock.js";
+import { projectilesPart, toldAttack, toldAttackCancelled, toldImpact, toldMiss, toldShot } from "./systems/combatTold.js";
+import { areasPart } from "./abilities/screen.js";
+import { resolveScore, scoreLinePart, scorePart, scoreSystem } from "./score.js";
+import { supplySystem, toldChop, toldResource } from "./systems/economy.js";
+import { foliageDebugCommands } from "./foliageDebug.js";
+import { gateStates, setUpGates } from "./gates.js";
+import { tuneCommand } from "./tunables.js";
+import { spawnCamp } from "./camps.js";
+import { allOrFreed } from "./navigation/builds.js";
+import { RecastNavigation } from "./navigation/recast.js";
+import { SidePaths, sideKnowledgeSystem } from "./navigation/sidePaths.js";
+import { SizedNavigation } from "./navigation/sized.js";
+import { attackGroundOrder, attackMoveOrder, attackOrder, attackPathOrder, followOrder, followPathOrder, holdOrder, moveOrder, patrolOrder, patrolPathOrder } from "./orders/basic.js";
+import { dropItemOrder, pickUpOrder } from "./orders/items.js";
+import { Registry } from "./registry.js";
+import { abilitySystem } from "./systems/abilities.js";
+import { lifeSystem } from "./systems/life.js";
+import { SaveError, restoreWorld, savedPlayers, updateSave } from "./save.js";
+import { World } from "./world.js";
+import { coreComponents } from "./coreComponents.js";
+//#region src/game.ts
+var coreOrders = [
+	moveOrder,
+	holdOrder,
+	attackOrder,
+	attackMoveOrder,
+	followPathOrder,
+	attackPathOrder,
+	patrolPathOrder,
+	attackGroundOrder,
+	patrolOrder,
+	followOrder,
+	harvestOrder,
+	returnOrder,
+	buildOrder,
+	constructOrder,
+	repairOrder,
+	castOrder,
+	pickUpOrder,
+	dropItemOrder,
+	boardOrder,
+	loadOrder,
+	unloadOrder
+];
+/**
+* The systems the engine brings along, by phase: decisions first, then movement, then everything that reacts to where
+* units ended up. Within a phase, in this order. A module can do without any of them by name (`Rules.withoutSystems`),
+* or put its own in place of one by giving a system the same name
+*
+* @beta
+*/
+var coreSystems = [
+	timerSystem,
+	abilitySystem,
+	orderSystem,
+	movementSystem,
+	combatSystem,
+	constructionSystem,
+	productionSystem,
+	supplySystem,
+	areaSystem,
+	formSystem,
+	lifeSystem,
+	fogSystem,
+	sequenceSystem,
+	transportSystem,
+	corpseSystem
+];
+/**
+* How the engine's events are told to the players, each written beside what emits it, in the order a seat hears them:
+* two told of one event (a hit and its critical number) are told in this order
+*/
+var coreReplications = [
+	toldDeath,
+	toldCells,
+	toldCellsSeen,
+	toldRedefined,
+	toldEnvironment,
+	toldGround,
+	toldCommand,
+	toldAttack,
+	toldAttackCancelled,
+	toldDamage,
+	toldHeal,
+	toldBuffOn,
+	toldBuffOff,
+	toldTrained,
+	toldConstructionStarted,
+	toldBuilt,
+	toldConstructionCancelled,
+	toldUpgradeStarted,
+	toldUpgradeCancelled,
+	toldMorphed,
+	toldRevived,
+	toldPicked,
+	toldResearched,
+	toldShot,
+	toldMissileHit,
+	toldWindup,
+	toldCastCancelled,
+	toldChannelStarted,
+	toldChannelEnded,
+	toldCast,
+	toldStrike,
+	toldCrit,
+	toldMiss,
+	toldImpact,
+	toldWork,
+	toldChop,
+	toldLevelUp,
+	toldXp,
+	toldMana,
+	toldResource,
+	toldBounty,
+	toldMessage,
+	toldObjective,
+	toldLine,
+	toldLineEnded,
+	toldCinematic,
+	toldCinematicCue,
+	toldCamera,
+	toldFx,
+	toldFxStopped,
+	toldRustle,
+	toldGust,
+	toldPing,
+	toldChat
+];
+/** What the game tells each player about itself, with its packs' beside it (`Snapshot.report`, `Rules.report`) */
+var reportPart = snapshotField("report", ({ world, player }) => world.registry.report?.(world, player));
+/** The engine's parts of a player's snapshot, each captured by its feature, in their order (`SnapshotField`) */
+var coreSnapshotParts = [
+	debugPart,
+	hourPart,
+	outcomePart,
+	projectilesPart,
+	missilesPart,
+	itemsPart,
+	revealsPart,
+	areasPart,
+	cameraPart,
+	eventsPart,
+	reportPart,
+	scorePart,
+	scoreLinePart,
+	corpsesPart
+];
+/**
+* The engine's parts that give an entity something as it is made, or call it off as it leaves its owner: a worker's
+* load, a building's queue, the slots of what carries, a hold
+*/
+var coreParts = [
+	gathering,
+	productionQueue,
+	inventorySlots,
+	cargo
+];
+/** Each game's assembly, made once */
+var assemblies = /* @__PURE__ */ new WeakMap();
+/**
+* A game with its packs put together (`AssembledGame`): what the registry, the systems, the hooks, the listeners and the
+* timers of a world of it are made of. Refuses a pack without one it says it goes with (`GamePack.requires`)
+*
+* @beta
+*/
+function assembleGame(game) {
+	const known = assemblies.get(game);
+	if (known) return known;
+	const packs = game.packs ?? [];
+	for (const pack of packs) for (const needed of pack.requires ?? []) if (!packs.some((each) => each.id === needed)) throw new Error(`The pack "${pack.id}" goes with the pack "${needed}", which "${game.id}" does not have`);
+	const from = (pick) => packs.flatMap((pack) => pick(pack) ?? []);
+	const withoutCommands = new Set(game.withoutCommands ?? []);
+	const withoutOrders = new Set(game.withoutOrders ?? []);
+	const withoutHooks = new Set(game.withoutHooks ?? []);
+	let settings = game.settings ?? {};
+	for (const pack of packs) {
+		if (!pack.settings) continue;
+		const over = pack.settings(resolveSettings(settings));
+		settings = overSettings(settings, over);
+	}
+	const reports = [game.report, ...packs.map((pack) => pack.report?.bind(pack))].filter((each) => each !== void 0);
+	const checks = [game.editor?.check, ...packs.map((pack) => pack.check?.bind(pack))].filter((each) => each !== void 0);
+	const victories = packs.filter((pack) => pack.victory !== void 0);
+	const assembly = {
+		rules: game,
+		commands: [...from((pack) => pack.commands).filter((command) => !withoutCommands.has(command.type)), ...game.commands ?? []],
+		orders: [...from((pack) => pack.orders).filter((order) => !withoutOrders.has(order.type)), ...game.orders ?? []],
+		packSystems: from((pack) => pack.systems),
+		hooks: [...from((pack) => pack.hooks).filter((hook) => !withoutHooks.has(hook.id)), ...game.hooks ?? []],
+		listeners: [...from((pack) => pack.listeners), ...game.listeners ?? []],
+		effects: [...from((pack) => pack.effects), ...game.effects ?? []],
+		timers: [...from((pack) => pack.timers), ...game.timers ?? []],
+		components: [...from((pack) => pack.components), ...game.components ?? []],
+		events: [...from((pack) => pack.events), ...game.events ?? []],
+		statFields: from((pack) => pack.statFields),
+		stats: [...from((pack) => pack.stats), ...game.stats ?? []],
+		replications: from((pack) => pack.replications),
+		snapshotFields: from((pack) => pack.snapshotFields),
+		settings,
+		report: reports.length ? (world, player) => Object.assign({}, ...reports.map((report) => report(world, player))) : null,
+		victory: game.victory !== void 0 ? game.victory : victories.at(-1)?.victory,
+		check: checks.length ? (map, registry) => checks.flatMap((check) => check(map, registry)) : void 0
+	};
+	assemblies.set(game, assembly);
+	return assembly;
+}
+/**
+* Everything a game module defines, looked up by id: with the engine's own components, and those an app keeps in its
+* worlds (`own`: `CreateWorldOptions.components`)
+*
+* @public
+*/
+function createRegistry(game, own = []) {
+	const registry = new Registry();
+	registry.defineCore(coreComponents());
+	const assembly = assembleGame(game);
+	registry.assembly = assembly;
+	const withoutOrders = new Set(game.withoutOrders ?? []);
+	for (const order of coreOrders) if (!withoutOrders.has(order.type)) registry.orders.define(order);
+	for (const order of assembly.orders) registry.orders.define(order);
+	for (const formation of coreFormations) registry.formations.define(formation);
+	for (const formation of game.formations ?? []) registry.formations.define(formation);
+	const withoutCommands = new Set(game.withoutCommands ?? []);
+	for (const command of [
+		...coreCommands.filter((command) => !withoutCommands.has(command.type)),
+		...debugCommands,
+		...foliageDebugCommands,
+		tuneCommand,
+		redefineCommand
+	]) registry.commands.define(command);
+	for (const command of assembly.commands) registry.commands.define(command);
+	for (const kind of [
+		...coreEffects,
+		...summonEffects,
+		...dispelEffects,
+		...assembly.effects
+	]) registry.effects.define(kind);
+	for (const targeting of game.targetings ?? []) registry.targetings.define(targeting);
+	for (const buff of game.buffs ?? []) registry.buffs.define(buff);
+	for (const ability of game.abilities ?? []) registry.abilities.define(ability);
+	for (const item of game.items ?? []) registry.items.define(itemTier(item) === item.tier ? item : {
+		...item,
+		tier: itemTier(item)
+	});
+	for (const tag of game.tags ?? []) registry.tags.define(tag);
+	for (const prefab of game.prefabs ?? []) registry.prefabs.define(prefab);
+	registry.upkeep = [...game.upkeep ?? []].sort((a, b) => a.above - b.above);
+	registry.game = game.id;
+	registry.module = game;
+	registry.day = game.day ?? null;
+	registry.settings = resolveSettings(assembly.settings);
+	registry.score = resolveScore(registry.settings.score, game);
+	registry.report = assembly.report;
+	registry.resources = [...game.resources ?? []];
+	registry.currency = game.currency ?? game.resources?.[0]?.id ?? null;
+	registry.tiles = checkTiles(game.tiles ?? []);
+	registry.cellLayers = game.cellLayers ?? [];
+	registry.tunables = [...game.tunables ?? []];
+	registry.defineParts([...assembly.components, ...own], assembly.events);
+	const parts = [...coreParts, ...assembly.components];
+	registry.spawning = parts.filter((part) => part.onSpawn);
+	registry.leaving = parts.filter((part) => part.onLeave);
+	registry.passing = parts.filter((part) => part.passable);
+	defineStats(registry, assembly.stats);
+	registry.statFields = [...assembly.statFields];
+	registry.replications = [...coreReplications, ...assembly.replications];
+	registry.snapshotFields = [...coreSnapshotParts, ...assembly.snapshotFields];
+	for (const race of game.races ?? []) registry.races.define(race);
+	for (const file of game.files ?? []) registry.setFile(file, file.read(file.data));
+	for (const unit of game.units) registry.units.define(unit);
+	for (const upgrade of game.upgrades ?? []) registry.upgrades.define(upgrade);
+	checkCosts(game);
+	checkRaces(game);
+	checkStats(game, new Set(registry.statKeys));
+	checkSaves(game);
+	return registry;
+}
+/**
+* Throws when what a game says of its saves cannot be: a version that is no whole number from 1, or a step from a
+* version the game is not past yet, which would never run
+*/
+function checkSaves(game) {
+	const { version = 1, migrate } = game.saves ?? {};
+	if (!Number.isInteger(version) || version < 1) throw new Error(`The version of the saves of "${game.id}" is a whole number from 1, not ${String(version)}`);
+	if (typeof migrate !== "object") return;
+	for (const from of Object.keys(migrate).map(Number)) if (!Number.isInteger(from) || from < 1 || from >= version) throw new Error(`"${game.id}" has a step for saves of version ${from}, and its saves are of version ${version}: the steps are from 1 to ${version - 1}, each to the version after it`);
+}
+/** The game's tiles, as they are: throws for one that is there twice, or for too many to keep in a byte */
+function checkTiles(tiles) {
+	if (tiles.length > 255) throw new Error(`A game has at most 255 tiles, not ${tiles.length}`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const tile of tiles) {
+		if (seen.has(tile.id)) throw new Error(`The tile "${tile.id}" is there twice`);
+		seen.add(tile.id);
+	}
+	return [...tiles];
+}
+/** The game's own stats next to the engine's, and what every unit starts with of them */
+function defineStats(registry, stats) {
+	const defaults = { ...noStats() };
+	for (const stat of stats) {
+		if (stat.id in defaults) throw new Error(`The stat "${stat.id}" is there twice, or is one of the engine's`);
+		defaults[stat.id] = stat.default ?? 0;
+	}
+	registry.stats = [...stats];
+	registry.statKeys = Object.keys(defaults);
+	registry.statDefaults = Object.freeze(defaults);
+}
+/**
+* Throws when something changes or scales with a stat the game does not have: most likely a typo, which would
+* otherwise do nothing, or turn a stat into NaN. Stats are any text to the type checker, so this is where it is caught
+*/
+function checkStats(game, known) {
+	const check = (what, keys, also = []) => {
+		for (const key in keys) if (!known.has(key) && !also.includes(key)) throw new Error(`${what} has the stat "${key}", which the game does not have`);
+	};
+	const change = (what, change) => {
+		check(what, change?.stats);
+		check(what, change?.percent);
+	};
+	const scaling = (what, within) => {
+		if (typeof within !== "object" || within === null) return;
+		for (const [key, value] of Object.entries(within)) if (key === "scaling" || key === "shieldScaling") check(what, value, ["level", "bonusAttackDamage"]);
+		else scaling(what, value);
+	};
+	for (const unit of game.units) {
+		check(`Unit type "${unit.id}"`, unit.stats);
+		change(`The growth of "${unit.id}"`, unit.hero?.growth);
+		for (const [i, attack] of (unit.attacks ?? []).entries()) for (const stat of Object.values(attack.stats ?? {})) if (!known.has(stat)) throw new Error(`Attack ${i + 1} of "${unit.id}" reads the stat "${stat}", which the game does not have`);
+	}
+	for (const buff of game.buffs ?? []) {
+		change(`Buff "${buff.id}"`, buff);
+		scaling(`Buff "${buff.id}"`, buff);
+	}
+	for (const item of game.items ?? []) change(`Item "${item.id}"`, item.bonus);
+	for (const upgrade of game.upgrades ?? []) for (const effect of upgrade.effects) change(`Upgrade "${upgrade.id}"`, effect);
+	for (const ability of game.abilities ?? []) scaling(`Ability "${ability.id}"`, ability);
+}
+/**
+* Throws when something costs a resource the game does not have: a typo, or something that is not a resource at
+* all, like supply. Either would otherwise make it something nobody can ever afford, without a word
+*/
+function checkCosts(game) {
+	const known = new Set((game.resources ?? []).map((resource) => resource.id));
+	if (game.currency !== void 0 && !known.has(game.currency)) throw new Error(`The currency "${game.currency}" is not a resource of the game`);
+	const check = (what, cost) => {
+		for (const kind in cost) if (!known.has(kind)) throw new Error(`${what} costs "${kind}", which is not a resource of the game`);
+	};
+	for (const unit of game.units) check(`Unit type "${unit.id}"`, unit.cost);
+	for (const upgrade of game.upgrades ?? []) check(`Upgrade "${upgrade.id}"`, upgrade.cost);
+	for (const item of game.items ?? []) check(`Item "${item.id}"`, item.cost);
+}
+/** Where the groups of ground units' radii end (the last group is over the last edge) */
+var BUCKET_EDGES = [.5, .75];
+/**
+* The sizes the ground units of a game are cut for (`radii: 'auto'`): their radii in groups (up to 0.5, up to 0.75,
+* over), each cut for its largest radius (the first for 0.5 at least), a group only where a unit type falls in it. Each
+* with the radius of the biggest unit it takes, `upTo`. What flies or sails has navigation of its own
+*/
+function autoNavigationSizes(registry) {
+	const largest = new Array(BUCKET_EDGES.length + 1).fill(0);
+	for (const def of registry.units.all()) {
+		if (def.kind !== "unit" || def.flying || def.naval) continue;
+		const bucket = BUCKET_EDGES.findIndex((edge) => def.radius <= edge);
+		const i = bucket < 0 ? BUCKET_EDGES.length : bucket;
+		largest[i] = Math.max(largest[i], def.radius);
+	}
+	const sizes = [];
+	largest.forEach((radius, i) => {
+		if (radius > 0) sizes.push({
+			radius: i === 0 ? Math.max(radius, .5) : radius,
+			upTo: i < BUCKET_EDGES.length ? BUCKET_EDGES[i] : Infinity
+		});
+	});
+	return sizes;
+}
+/**
+* The ground's navigation: cut for a unit of ordinary size (0.5), for each size the game names (`radii`), or for each
+* group of sizes its unit types are in (`autoSizes`), each unit on the one for its size. Big ones on one cut for 0.5
+* fit through the same gaps and overlap walls a little, which is better than everyone keeping the distance from a wall
+* that the biggest unit in the game needs
+*/
+async function groundNavigationOf(terrain, options = {}, autoSizes) {
+	const named = [...new Set(options.radii ?? [])].sort((a, b) => a - b);
+	const wanted = autoSizes ?? named.map((radius) => ({ radius }));
+	if (wanted.length < 2 || !terrain.buildMesh(true).indices.length) return RecastNavigation.create(terrain, {
+		agentRadius: wanted[0]?.radius ?? .5,
+		...options,
+		radii: void 0
+	});
+	const navigations = await allOrFreed(wanted.map(({ radius }) => () => RecastNavigation.create(terrain, {
+		...options,
+		agentRadius: radius,
+		radii: void 0
+	})));
+	return new SizedNavigation(wanted.map(({ radius, upTo }, i) => ({
+		radius,
+		upTo,
+		navigation: navigations[i]
+	})));
+}
+/**
+* The navigations the sides plan their routes on (`Rules.paths: 'seen'`): one for each team that plays, cut for
+* the game's smallest unit. None where routes know everything
+*/
+async function sidePathsOf(game, terrain, players, options) {
+	if (game.paths !== "seen") return void 0;
+	const teams = [...new Set(players.filter((player) => !player.neutral && !player.creeps).map((player) => player.team))].sort((a, b) => a - b);
+	const radius = Math.min(...options.radii?.length ? options.radii : [options.agentRadius ?? .5]);
+	return SidePaths.create(terrain, teams, {
+		...options,
+		agentRadius: radius
+	});
+}
+/** Where boats go, on a map with deep water: a navigation of the water at its surface. Nothing on one without */
+async function waterNavigationOf(terrain, options) {
+	if (!terrain.hasDeepWater) return void 0;
+	return RecastNavigation.create(terrain, {
+		agentRadius: .5,
+		...options,
+		...options?.radii?.length && { agentRadius: Math.min(...options.radii) },
+		surface: "water"
+	});
+}
+/**
+* Makes a world from terrain, rules and players; resolves once it is ready to step
+*
+* @public
+*/
+async function createWorld(options) {
+	const { terrain, rules: game, players, seed } = options;
+	const world = await makeWorld(game, createRegistry(game, options.components), terrain, {
+		players: players.map((player) => ({
+			...player,
+			resources: startingResources(game, player)
+		})),
+		navigation: options.navigation,
+		randomRaces: options.randomRaces,
+		seed,
+		tickRate: options.tickRate,
+		log: options.log,
+		onError: options.onError,
+		checks: options.checks
+	});
+	raceResources(world, players);
+	world.sidePaths?.attach(world);
+	return world;
+}
+/**
+* A world of a game on a terrain, its navigations built (freed again where what follows fails), its parts the game's put
+* together with its packs (`assembleGame`): what a world made new and a world loaded from a save have in common
+*/
+async function makeWorld(game, registry, terrain, options) {
+	const { radii, ...given } = {
+		...game.navigation,
+		...options.navigation
+	};
+	const navigationOptions = {
+		...hasGroundSpeeds(registry) && { speedAt: (x, z) => navigationSpeedOn(registry, terrain, x, z) },
+		...given,
+		...Array.isArray(radii) && { radii }
+	};
+	const sizes = (radii === void 0 || radii === "auto") && given.agentRadius === void 0 ? autoNavigationSizes(registry) : void 0;
+	const [navigation, waterNavigation, sidePaths] = await allOrFreed([
+		() => groundNavigationOf(terrain, navigationOptions, sizes),
+		() => waterNavigationOf(terrain, navigationOptions),
+		() => sidePathsOf(game, terrain, options.players, navigationOptions)
+	]);
+	const assembly = registry.assembly;
+	return freedOnError(navigation, () => freedOnError(waterNavigation, () => new World({
+		terrain,
+		navigation,
+		waterNavigation,
+		sidePaths,
+		registry,
+		players: options.players,
+		randomRaces: options.randomRaces,
+		seed: options.seed,
+		tickRate: options.tickRate,
+		log: options.log,
+		logLevel: game.log?.level,
+		onError: game.onError ?? options.onError,
+		checks: options.checks,
+		systems: (world) => systemsOf(world, assembly),
+		hooks: hooksOf(assembly),
+		listeners: listenersOf(assembly),
+		areas: game.areas,
+		timers: timersOf(assembly),
+		sequences: game.sequences
+	})));
+}
+/**
+* Runs what makes something of a navigation already made: the navigation is freed when it fails (WebAssembly memory,
+* which nothing else would free), and the error goes on
+*/
+async function freedOnError(navigation, make) {
+	try {
+		return await make();
+	} catch (error) {
+		navigation?.dispose();
+		throw error;
+	}
+}
+/** Runs what is done to a world just made: the world is disposed when it fails, and the error goes on */
+async function disposedOnError(world, run) {
+	try {
+		await run();
+		return world;
+	} catch (error) {
+		world.dispose();
+		throw error;
+	}
+}
+/**
+* What a player starts with: what they were given, or else what the game starts everyone with (nothing, for the
+* neutral players). Every resource of the game is in it, at 0 at least
+*/
+function startingResources(game, player) {
+	const purse = {};
+	for (const resource of game.resources ?? []) purse[resource.id] = player.resources ? player.resources[resource.id] ?? 0 : player.neutral ? 0 : resource.start ?? 0;
+	return {
+		...player.resources,
+		...purse
+	};
+}
+/**
+* A world from a save (see `saveWorld`), carrying on where it was. A save made before, by an older engine or by the
+* game before a patch, is brought up to date first (`updateSave`), or refused with a `SaveError` that says why.
+* Navigation is built again; units come back with the speed and destination they had, but the way they find around
+* each other is worked out anew, so the game from there on is close to, and not quite, the one that was saved
+*
+* @public
+*/
+async function loadWorld(saved, options) {
+	const kept = (saved.state?.[mapInfo.id])?.definitions;
+	const definitions = options.map ? options.map.definitions : kept;
+	const game = definitions ? layData(options.rules, definitions) : options.rules;
+	const registry = createRegistry(game, options.components);
+	const save = updateSave(saved, registry, { anyVersion: options.anyVersion });
+	let ground;
+	try {
+		ground = groundOf(save.terrain, options.maps ?? game.maps, game);
+	} catch (error) {
+		if (error instanceof MissingGround) throw new SaveError(`Save: ${error.message}`, "ground");
+		throw error;
+	}
+	const { terrain } = ground;
+	const world = await makeWorld(game, registry, terrain, {
+		players: savedPlayers(save),
+		navigation: options.navigation,
+		tickRate: save.tickRate,
+		log: options.log,
+		onError: options.onError,
+		checks: options.checks
+	});
+	return disposedOnError(world, () => {
+		world.ground = ground.base;
+		restoreWorld(world, save);
+		if (save.state && gateStates.id in save.state) setUpGates(world);
+		world.computers.restore();
+		game.afterLoad?.(world);
+	});
+}
+/** The systems of a world of the game: the core ones and its packs', but those it leaves out, then its own, then who wins */
+function systemsOf(world, assembly) {
+	const { rules: game } = assembly;
+	const make = (def) => typeof def === "function" ? def(world) : def;
+	const without = new Set(game.withoutSystems ?? []);
+	const systems = [...coreSystems, ...assembly.packSystems.map(make)].filter((system) => !without.has(system.name));
+	for (const def of game.systems ?? []) {
+		const system = make(def);
+		const index = systems.findIndex((core) => core.name === system.name);
+		if (index < 0) systems.push(system);
+		else systems[index] = system.phase ? system : {
+			...system,
+			phase: systems[index].phase,
+			update: system.update?.bind(system),
+			each: system.each?.bind(system)
+		};
+	}
+	if (game.paths === "seen") systems.splice(systems.findIndex((system) => system.name === "fog") + 1, 0, sideKnowledgeSystem);
+	if (world.registry.score) systems.push(scoreSystem(world));
+	if (assembly.victory !== null) systems.push(make(assembly.victory ?? lastTeamStanding));
+	return systems;
+}
+function hooksOf(assembly) {
+	const without = new Set(assembly.rules.withoutHooks ?? []);
+	return [
+		...coreHooks.filter((hook) => !without.has(hook.id)),
+		...assembly.hooks,
+		...raceHooks(assembly.rules)
+	];
+}
+/** How the world reacts to events: the engine's, the packs', the game's */
+function listenersOf(assembly) {
+	return [
+		dropFromTable,
+		transportSank,
+		regionCinematic,
+		...assembly.listeners
+	];
+}
+/** What can be set to go off later: the packs' and the game's */
+function timersOf(assembly) {
+	return assembly.timers.length ? [...assembly.timers] : void 0;
+}
+/**
+* A world as a map lays it out: its ground, the players it has room for, and everything placed on it.
+* Players with a start location that the map places nothing for get what the game starts everyone with.
+* Throws for a map made for another game (`GameMap.game`).
+*
+* @public
+*/
+async function createWorldFromMap(options) {
+	const { map } = options;
+	const game = map.definitions ? layData(options.rules, map.definitions) : options.rules;
+	if (map.game !== void 0 && map.game !== game.id) throw new Error(`"${map.name}" is a map for the game "${map.game}", not for "${game.id}"`);
+	const most = maxPlayersOf(game);
+	const seated = map.players.filter((player) => player.id !== 90 && player.id !== 0).length;
+	if (seated > most) throw new Error(`"${map.name}" has ${seated} players, and ${game.name} allows ${most} (\`Rules.maxPlayers\`)`);
+	const creeps = options.creeps ?? (map.camps.length > 0 || map.objects.some((object) => object.owner === 90));
+	const players = [
+		{
+			id: 0,
+			name: "Neutral",
+			team: 0,
+			color: [
+				.8,
+				.75,
+				.4
+			],
+			neutral: true
+		},
+		...map.players.map((player) => ({
+			id: player.id,
+			name: player.name,
+			team: options.teams?.[player.id] ?? player.team,
+			color: options.colors?.[player.id] ?? player.color,
+			...player.resources && { resources: { ...player.resources } },
+			...(options.races?.[player.id] ?? player.race) !== void 0 && { race: options.races?.[player.id] ?? player.race }
+		})),
+		...creeps ? [{
+			id: 90,
+			name: "Creeps",
+			team: 1e3,
+			color: [
+				.42,
+				.36,
+				.3
+			],
+			creeps: true
+		}] : []
+	];
+	const terrain = startingTerrain(map, game);
+	const base = startedOn(map.name, cloneTerrain(terrain));
+	const world = await createWorld({
+		terrain,
+		rules: game,
+		players,
+		...map.races?.length && { randomRaces: map.races },
+		seed: options.seed,
+		navigation: options.navigation,
+		...options.components && { components: options.components },
+		log: options.log,
+		onError: options.onError,
+		checks: options.checks
+	});
+	world.ground = base;
+	return disposedOnError(world, () => {
+		world.setState(mapInfo, {
+			name: map.name,
+			data: fieldValues(mapFields(world.registry), structuredClone(map.data), map),
+			points: structuredClone(map.points),
+			paths: structuredClone(map.paths),
+			...map.environment && { environment: structuredClone(map.environment) },
+			...map.doodads.length > 0 && { doodads: structuredClone(map.doodads) },
+			...map.regions.length > 0 && { regions: structuredClone(map.regions) },
+			...map.cameras.length > 0 && { cameras: structuredClone(map.cameras) },
+			players: map.players.map((player) => ({
+				id: player.id,
+				...player.controller && { controller: player.controller },
+				data: mapPlayerData(world.registry, player, map)
+			})),
+			...map.forces?.length && { forces: structuredClone(map.forces) },
+			...map.itemTables?.length && { itemTables: structuredClone(map.itemTables) },
+			...map.definitions && { definitions: structuredClone(map.definitions) }
+		});
+		setUpGates(world);
+		for (const force of map.forces ?? []) {
+			if (!force.sharedControl) continue;
+			const members = map.players.filter((player) => player.team === force.team);
+			for (const one of members) for (const other of members) if (one !== other) world.sides.shareControl(one.id, other.id);
+		}
+		world.fog.exploreFromStart(map.explored ?? world.settings.fog?.startExplored ?? false);
+		if (map.day?.start !== void 0) world.clock.setHour(map.day.start);
+		if (map.day?.still) world.clock.stop();
+		for (const region of map.regions) {
+			if (world.areas.has(region.name)) throw new Error(`The region "${region.name}" of "${map.name}" has the name of an area of the game`);
+			const area = {
+				id: region.name,
+				shape: { ...region.shape }
+			};
+			world.areas.add(area);
+			if (world.hooks.has("mapRegion")) world.hooks.run("mapRegion", {
+				area,
+				region,
+				data: mapRegionData(world.registry, region, map)
+			});
+		}
+		const known = new Set(players.map((player) => player.id));
+		const placed = /* @__PURE__ */ new Set();
+		const groups = new Map((map.randomGroups ?? []).map((group) => [group.name, group]));
+		const drawn = (type, random) => {
+			const group = random === void 0 ? void 0 : groups.get(random);
+			return (group && drawFromGroup(group, world.registry, world.rng)) ?? type;
+		};
+		const objects = map.objects.map((object) => object.random ? {
+			...object,
+			type: drawn(object.type, object.random)
+		} : object).filter((object) => world.registry.units.has(object.type) && known.has(object.owner));
+		const rank = (type) => ({
+			resource: 0,
+			building: 1,
+			unit: 2
+		})[world.registry.unit(type).kind] ?? 1;
+		objects.sort((a, b) => rank(a.type) - rank(b.type));
+		let held = true;
+		world.nav.holdObstacles?.(true);
+		const letGo = () => {
+			if (held) world.nav.holdObstacles?.(false);
+			held = false;
+		};
+		/** Units of the map with orders of their own, given once everything stands (a path's ends, a guard's post) */
+		const ordered = [];
+		for (const object of objects) {
+			if (held && rank(object.type) === 2) letGo();
+			const entity = spawnMapObject(world, object, map);
+			if (object.orders?.length) ordered.push([entity, object.orders]);
+			placed.add(object.owner);
+		}
+		letGo();
+		for (const [entity, orders] of ordered) giveMapOrders(world, entity, orders);
+		for (const camp of map.camps) {
+			const units = camp.units.map((type) => type.startsWith("@") ? drawn("", type.slice(1)) : type).filter((type) => world.registry.units.has(type));
+			if (!units.length) continue;
+			const made = spawnCamp(world, 90, camp, units);
+			if (camp.name) made.name = camp.name;
+			if (camp.respawn !== void 0) made.respawn = camp.respawn;
+			if (world.hooks.has("mapCamp")) world.hooks.run("mapCamp", {
+				camp: made,
+				from: camp,
+				data: mapCampData(world.registry, camp, map)
+			});
+		}
+		const raceDef = (player) => {
+			const race = world.players.get(player)?.race;
+			return race === void 0 ? void 0 : world.registry.race(race);
+		};
+		for (const player of map.players) if (player.start && !placed.has(player.id)) spawnStartingBase(world, raceDef(player.id)?.startingBase ?? game.startingBase, player.id, player.start);
+		for (const player of map.players) {
+			const race = raceDef(player.id);
+			if (race && race.inherits?.onStart !== false) race.onStart?.(world, player.id);
+		}
+		if (world.hooks.has("mapStart")) world.hooks.run("mapStart", { map });
+	});
+}
+/**
+* Players a map of the game may have (`Rules.maxPlayers`): 8 when it says nothing, never more than the fog keeps apart
+*
+* @beta
+*/
+var maxPlayersOf = (game) => Math.max(1, Math.min(Math.floor(game.maxPlayers ?? 8), 32));
+//#endregion
+export { assembleGame, autoNavigationSizes, coreSystems, createRegistry, createWorld, createWorldFromMap, loadWorld, maxPlayersOf };
+
+//# sourceMappingURL=game.js.map