@v12-engine/engine 0.1.1 → 0.4.0

package/dist/{simulate-oXBiw1Ff.js → simulate.js}

@@ -1,31 +1,30 @@
-import "./debugCommands-CzjrSm66.js";
-import { a as createWorldFromMap } from "./game-DiJEN-Ks.js";
+import "./map/types.js";
+import { createWorldFromMap } from "./game.js";
 //#region src/simulate.ts
 /** A simulation, as a module that a worker imports gives it: as it is written, for its type *
 * @beta
 */
-var defineSimulation = (simulation) => simulation;
 /** Plays one game of a simulation from a seed, in this thread *
 * @beta
 */
 async function playGame(simulation, seed) {
 	const began = performance.now();
-	const { game, map } = simulation;
+	const { rules: game, map } = simulation;
 	const world = await createWorldFromMap({
 		map: structuredClone(map),
-		game,
+		rules: game,
 		seed,
 		onError: "end"
 	});
 	try {
 		const starts = map.players.filter((player) => player.start && player.id !== 90);
 		const computers = simulation.computers ?? starts.map((player) => player.id);
-		simulation.start?.(world);
+		simulation.onStart?.(world);
 		for (const player of computers) {
 			const enemyBases = starts.filter((other) => other.id !== player && world.areEnemies(player, other.id)).map((other) => other.start);
 			const named = simulation.brains?.[player];
 			const brain = typeof named === "string" ? world.computers.brain(named) : named;
-			if (typeof named === "string" && !brain) throw new Error(`No brain is called "${named}": list it in GameModule.brains, or give the brain itself`);
+			if (typeof named === "string" && !brain) throw new Error(`No brain is called "${named}": list it in Rules.brains, or give the brain itself`);
 			const difficulty = simulation.difficulties?.[player];
 			const options = {
 				enemyBases,
@@ -112,10 +111,10 @@ function winRates(games) {
 /**
 * Plays games of a simulation, one from each seed, and gives what each ended in, in the order of the seeds. Given as
 * it is, they are played in this thread. Given as the address of a file (a module whose `default`, or `simulation`, is
-* one: `defineSimulation`), each worker thread imports it and plays its share: in Node, from the built packages (a
+* one: a `Simulation`), each worker thread imports it and plays its share: in Node, from the built packages (a
 * worker loads JavaScript, not the TypeScript of this repository)
 *
-* @beta
+* @public
 */
 async function simulate(simulation, options) {
 	if (typeof simulation !== "string" && !(simulation instanceof URL)) {
@@ -162,6 +161,6 @@ async function simulate(simulation, options) {
 	return options.seeds.map((seed) => results.get(seed));
 }
 //#endregion
-export { winRates as i, playGame as n, simulate as r, defineSimulation as t };
+export { playGame, simulate, winRates };
 
-//# sourceMappingURL=simulate-oXBiw1Ff.js.map
+//# sourceMappingURL=simulate.js.map

package/dist/simulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.js","names":[],"sources":["../src/simulate.ts"],"sourcesContent":["import type { AiOptions } from './ai/options'\nimport type { AiStats } from './ai/report'\nimport type { BrainDef } from './ai/brain'\nimport type { PlayerId } from './entity'\nimport { createWorldFromMap, type Rules } from './game'\nimport { type GameMap, MAP_CREEPS } from './map'\nimport type { World } from './world'\n\n/*\n * Many games at once, for balance (S43): games of a game played at full speed by the computer, from seeds, each\n * ending in plain data (who won, how long it took, what the game asked to count). The same seed gives the same game.\n * In this thread (`simulate(simulation, …)`), or in worker threads, each of which imports the game itself from a file\n * (`simulate(url, { workers })`): a game's rules are functions, which cannot be sent to another thread.\n */\n\n/**\n * What a value counted at the end of a game may be: plain data, which comes back from a worker as it went\n *\n * @beta\n */\nexport type Counted = number | string | boolean | null\n\n/**\n * A game to play many times (`simulate`): the rules, the map, who the computer plays and how, and what to count\n *\n * @public\n */\nexport interface Simulation {\n\t/** The game module's rules each simulated game is played with */\n\trules: Rules\n\t/** The map each simulated game is made from */\n\tmap: GameMap\n\t/**\n\t * The players the computer plays: every player of the map with a start, the creeps apart, when left out. One left\n\t * out is the game's own (`start`) to move, or stands\n\t */\n\tcomputers?: PlayerId[]\n\t/**\n\t * The brain each player is played by, or its id (one the game lists in `Rules.brains`, or the engine's\n\t * `core.melee`): two brains against each other, for a balance run. A player not named here is played by the first\n\t * brain the game lists\n\t */\n\tbrains?: Record<number, BrainDef | string>\n\t/**\n\t * How hard each player's computer plays, by name (`'hard'`): under what `ai` gives. The seat's own when left out\n\t */\n\tdifficulties?: Record<number, string>\n\t/** How the computer plays a player, over what it is given (`enemyBases`: where the others start) */\n\tai?: (player: PlayerId, world: World) => Partial<AiOptions>\n\t/** What the game does once a world is made, before the first tick: units of its own, a rule turned on */\n\tonStart?: (world: World) => void\n\t/** Seconds of the game at most: twenty minutes when left out */\n\tseconds?: number\n\t/** Whether the game is over before that: once there is a winner, when left out */\n\tuntil?: (world: World) => boolean\n\t/** What to count at the end of each game, by name: units alive, gold gathered, the hour */\n\tmeasure?: (world: World) => Record<string, Counted>\n}\n\n/**\n * How a computer player played one game, beside who won (`SimulatedGame.computers`): the numbers that say whether a\n * brain plays well, not only whether it won (`AiStats`, the brain's own counts, by the minute where it says so)\n *\n * @beta\n */\nexport interface ComputerMeasures {\n\t/** The brain that played the seat, by id: none for the first the game lists, seated by none named */\n\tbrain?: string\n\t/** The team the seat played for */\n\tteam: number\n\t/** Whether its team won: false for a draw too */\n\twon: boolean\n\t/** Commands sent a minute of the game */\n\tcommandsAMinute: number\n\t/** Seconds its fighters stood idle, summed over the fighters */\n\tidleArmySeconds: number\n\t/** Orders sent to a unit again for the same thing within a few seconds */\n\tchurn: number\n\t/** Seconds its building waited on money */\n\tblockedOnMoney: number\n\t/** Commands the game refused */\n\trefused: number\n\t/** Commands held back past what a think may send */\n\theld: number\n}\n\n/**\n * How one game ended\n *\n * @beta\n */\nexport interface SimulatedGame {\n\t/** The seed the game was played with */\n\tseed: number\n\t/** The winning team, or null for none in the time given */\n\twinner: number | null\n\t/** Seconds of the game it lasted, and ticks */\n\tseconds: number\n\t/** How many ticks the game lasted */\n\tticks: number\n\t/** Why it stopped on an error of its rules, where it did (`World.failure`) */\n\tfailed?: string\n\t/** What `measure` counted */\n\tmeasured: Record<string, Counted>\n\t/** How each computer player played, by player: commands a minute, idle army seconds, churn, seconds blocked on money, commands refused */\n\tcomputers: Record<string, ComputerMeasures>\n\t/** Milliseconds it took to play here */\n\ttook: number\n}\n\n/** A simulation, as a module that a worker imports gives it: as it is written, for its type *\n * @beta\n */\n\n/** Plays one game of a simulation from a seed, in this thread *\n * @beta\n */\nexport async function playGame(simulation: Simulation, seed: number): Promise<SimulatedGame> {\n\tconst began = performance.now()\n\tconst { rules: game, map } = simulation\n\tconst world = await createWorldFromMap({ map: structuredClone(map), rules: game, seed, onError: 'end' })\n\ttry {\n\t\tconst starts = map.players.filter((player) => player.start && player.id !== MAP_CREEPS)\n\t\tconst computers = simulation.computers ?? starts.map((player) => player.id)\n\t\tsimulation.onStart?.(world)\n\t\tfor (const player of computers) {\n\t\t\tconst enemyBases = starts.filter((other) => other.id !== player && world.areEnemies(player, other.id)).map((other) => other.start!)\n\t\t\tconst named = simulation.brains?.[player]\n\t\t\tconst brain = typeof named === 'string' ? world.computers.brain(named) : named\n\t\t\tif (typeof named === 'string' && !brain)\n\t\t\t\tthrow new Error(`No brain is called \"${named}\": list it in Rules.brains, or give the brain itself`)\n\t\t\tconst difficulty = simulation.difficulties?.[player]\n\t\t\tconst options: AiOptions = { enemyBases, ...(difficulty !== undefined && { difficulty }), ...simulation.ai?.(player, world) }\n\t\t\tworld.computers.seat(player, { ...options, brain })\n\t\t}\n\t\tconst until = simulation.until ?? ((done: World) => done.winner !== null)\n\t\tconst ticks = Math.ceil((simulation.seconds ?? 1200) * world.tickRate)\n\t\tlet tick = 0\n\t\twhile (tick < ticks && !world.failure && !until(world)) {\n\t\t\tworld.step()\n\t\t\ttick++\n\t\t}\n\t\tconst seconds = tick / world.tickRate\n\t\tconst measures: Record<string, ComputerMeasures> = {}\n\t\tfor (const player of computers) {\n\t\t\tconst computer = world.computers.get(player)?.computer as { stats?: AiStats; def?: { id: string } } | undefined\n\t\t\tconst stats = computer?.stats\n\t\t\tif (!stats) continue\n\t\t\tconst team = world.players.get(player)?.team ?? player\n\t\t\tmeasures[player] = {\n\t\t\t\t...(computer?.def?.id !== undefined && { brain: computer.def.id }),\n\t\t\t\tteam,\n\t\t\t\twon: world.winner !== null && world.winner === team,\n\t\t\t\tcommandsAMinute: seconds > 0 ? (stats.commands / seconds) * 60 : 0,\n\t\t\t\tidleArmySeconds: stats.idleArmySeconds,\n\t\t\t\tchurn: stats.churn,\n\t\t\t\tblockedOnMoney: stats.blockedOnMoney,\n\t\t\t\trefused: stats.refused,\n\t\t\t\theld: stats.held\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tseed,\n\t\t\twinner: world.winner,\n\t\t\tseconds,\n\t\t\tticks: tick,\n\t\t\t...(world.failure && { failed: world.failure.message }),\n\t\t\tmeasured: simulation.measure?.(world) ?? {},\n\t\t\tcomputers: measures,\n\t\t\ttook: performance.now() - began\n\t\t}\n\t} finally {\n\t\tworld.dispose()\n\t}\n}\n\n/**\n * How a brain did over some games (`winRates`): by seat, so a brain that played both sides of a game counts twice\n *\n * @beta\n */\nexport interface BrainResults {\n\t/** Seats it played */\n\tgames: number\n\t/** Seats whose team won */\n\twins: number\n\t/** Seats whose team another team beat */\n\tlosses: number\n\t/** Seats of games with no winner in the time given */\n\tdraws: number\n\t/** Wins over seats played */\n\trate: number\n\t/** Wins over games decided either way: draws left out */\n\tdecided: number\n}\n\n/**\n * The win rate of each brain over games of `simulate`, by brain id (`ComputerMeasures.brain`): what a balance run of two\n * brains reads. A seat that named no brain is left out\n *\n *     const games = await simulate({ ...duel, brains: { 1: meleeBrain, 2: myBrain } }, { seeds })\n *     winRates(games) // { 'core.melee': { rate: 0.4, … }, 'mygame.brain': { rate: 0.55, … } }\n *\n * @beta\n */\nexport function winRates(games: readonly SimulatedGame[]): Record<string, BrainResults> {\n\tconst results: Record<string, BrainResults> = {}\n\tfor (const game of games)\n\t\tfor (const measures of Object.values(game.computers)) {\n\t\t\tif (measures.brain === undefined) continue\n\t\t\tconst result = (results[measures.brain] ??= { games: 0, wins: 0, losses: 0, draws: 0, rate: 0, decided: 0 })\n\t\t\tresult.games++\n\t\t\tif (measures.won) result.wins++\n\t\t\telse if (game.winner === null) result.draws++\n\t\t\telse result.losses++\n\t\t}\n\tfor (const result of Object.values(results)) {\n\t\tresult.rate = result.games ? result.wins / result.games : 0\n\t\tresult.decided = result.wins + result.losses ? result.wins / (result.wins + result.losses) : 0\n\t}\n\treturn results\n}\n\n/**\n * How `simulate` plays its games\n *\n * @beta\n */\nexport interface SimulateOptions {\n\t/** The seeds to play from, a game each */\n\tseeds: number[]\n\t/**\n\t * Worker threads to play them in at once, where the simulation is given as a file: as many as the machine has\n\t * cores less one, when left out. In this thread, one after the other, for a simulation given as it is\n\t */\n\tworkers?: number\n\t/** Told of each game as it ends, in the order they end */\n\tonGame?: (game: SimulatedGame) => void\n}\n\n/**\n * Plays games of a simulation, one from each seed, and gives what each ended in, in the order of the seeds. Given as\n * it is, they are played in this thread. Given as the address of a file (a module whose `default`, or `simulation`, is\n * one: a `Simulation`), each worker thread imports it and plays its share: in Node, from the built packages (a\n * worker loads JavaScript, not the TypeScript of this repository)\n *\n * @public\n */\nexport async function simulate(simulation: Simulation | string | URL, options: SimulateOptions): Promise<SimulatedGame[]> {\n\tif (typeof simulation !== 'string' && !(simulation instanceof URL)) {\n\t\tconst games: SimulatedGame[] = []\n\t\tfor (const seed of options.seeds) {\n\t\t\tconst game = await playGame(simulation, seed)\n\t\t\toptions.onGame?.(game)\n\t\t\tgames.push(game)\n\t\t}\n\t\treturn games\n\t}\n\tconst { Worker } = await import('node:worker_threads')\n\tconst { availableParallelism } = await import('node:os')\n\tconst module = String(simulation)\n\tconst count = Math.max(1, Math.min(options.workers ?? availableParallelism() - 1, options.seeds.length))\n\t// the worker's file sits next to this one in the build: named so, a bundler leaves the address alone\n\tconst file = 'simulate-worker.js'\n\tconst script = new URL(file, import.meta.url)\n\tconst results = new Map<number, SimulatedGame>()\n\tconst queue = [...options.seeds]\n\tawait Promise.all(\n\t\tArray.from(\n\t\t\t{ length: count },\n\t\t\t() =>\n\t\t\t\tnew Promise<void>((resolve, reject) => {\n\t\t\t\t\tconst worker = new Worker(script)\n\t\t\t\t\tconst next = () => {\n\t\t\t\t\t\tconst seed = queue.shift()\n\t\t\t\t\t\tif (seed === undefined) {\n\t\t\t\t\t\t\tvoid worker.terminate()\n\t\t\t\t\t\t\treturn resolve()\n\t\t\t\t\t\t}\n\t\t\t\t\t\tworker.postMessage({ module, seed })\n\t\t\t\t\t}\n\t\t\t\t\tworker.on('message', (message: { game?: SimulatedGame; error?: string }) => {\n\t\t\t\t\t\tif (message.error !== undefined) {\n\t\t\t\t\t\t\tvoid worker.terminate()\n\t\t\t\t\t\t\treturn reject(new Error(message.error))\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresults.set(message.game!.seed, message.game!)\n\t\t\t\t\t\toptions.onGame?.(message.game!)\n\t\t\t\t\t\tnext()\n\t\t\t\t\t})\n\t\t\t\t\tworker.on('error', reject)\n\t\t\t\t\tnext()\n\t\t\t\t})\n\t\t)\n\t)\n\treturn options.seeds.map((seed) => results.get(seed)!)\n}\n"],"mappings":"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"}

package/dist/smart.js

@@ -0,0 +1,77 @@
+import { constructionOf } from "./defs.js";
+import { constructionSite } from "./systems/construction.js";
+import { deposit, moving } from "./entity.js";
+import { canAttack } from "./systems/combat.js";
+import { canHarvest, harvesterOf } from "./orders/harvest.js";
+import { canRepair } from "./orders/build.js";
+import { canBoard } from "./transport.js";
+//#region src/smart.ts
+/**
+* The right-click: picks the order a unit should get for whatever was clicked.
+* Returns undefined when there is nothing sensible for this unit to do.
+*/
+function smartOrder(world, entity, point, target) {
+	if (!entity.get(moving)) return void 0;
+	if (target && target !== entity) {
+		if (canAttack(world, entity, target)) return {
+			type: "attack",
+			target: target.id
+		};
+		if (target.def.fellable && entity.def.attacks?.some((attack) => attack.fells && attack.ground)) return {
+			type: "attackGround",
+			target: target.id
+		};
+		const harvester = harvesterOf(entity);
+		if (harvester) {
+			if (target.get(deposit)) return {
+				type: "harvest",
+				target: target.id
+			};
+			const under = world.get(target.on);
+			if (under?.get(deposit) && canHarvest(world, entity, under)) return {
+				type: "harvest",
+				target: under.id
+			};
+			if (target.def.dropOff && target.owner === entity.owner && target.operational && harvester.carrying > 0) return { type: "return" };
+		}
+		if (entity.def.builds?.length && target.has(constructionSite) && constructionOf(target.def) === "builder" && world.areAllies(entity.owner, target.owner)) return {
+			type: "construct",
+			target: target.id
+		};
+		if (entity.def.builds?.length && canRepair(world, entity.owner, target)) return {
+			type: "repair",
+			target: target.id
+		};
+		if (world.areEnemies(entity.owner, target.owner)) return {
+			type: "move",
+			point: {
+				x: target.pos.x,
+				z: target.pos.z
+			}
+		};
+		if (target.def.transport && canBoard(world, entity, target)) return {
+			type: "board",
+			target: target.id
+		};
+		if (entity.def.transport && canBoard(world, target, entity)) return {
+			type: "load",
+			target: target.id
+		};
+		if (target.get(moving) && world.areAllies(entity.owner, target.owner)) return {
+			type: "follow",
+			target: target.id
+		};
+		return {
+			type: "move",
+			target: target.id
+		};
+	}
+	return {
+		type: "move",
+		point
+	};
+}
+//#endregion
+export { smartOrder };
+
+//# sourceMappingURL=smart.js.map

package/dist/smart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart.js","names":[],"sources":["../src/smart.ts"],"sourcesContent":["import { constructionOf } from './defs'\nimport { constructionSite } from './systems/construction'\nimport type { Entity } from './entity'\nimport type { Vec2 } from './math'\nimport { canRepair } from './orders/build'\nimport { canHarvest, harvesterOf } from './orders/harvest'\nimport type { OrderInit } from './registry'\nimport { canAttack } from './systems/combat'\nimport { canBoard } from './transport'\nimport type { World } from './world'\nimport { moving, deposit } from './entity'\n\n/**\n * The right-click: picks the order a unit should get for whatever was clicked.\n * Returns undefined when there is nothing sensible for this unit to do.\n */\nexport function smartOrder(world: World, entity: Entity, point: Vec2, target?: Entity): OrderInit | undefined {\n\tif (!entity.get(moving)) return undefined\n\tif (target && target !== entity) {\n\t\tif (canAttack(world, entity, target)) return { type: 'attack', target: target.id }\n\t\t// trees are in the way of those who can bring them down\n\t\tif (target.def.fellable && entity.def.attacks?.some((attack) => attack.fells && attack.ground)) return { type: 'attackGround', target: target.id }\n\t\tconst harvester = harvesterOf(entity)\n\t\tif (harvester) {\n\t\t\tif (target.get(deposit)) return { type: 'harvest', target: target.id }\n\t\t\t// what stands on a resource (a cursed mine) is clicked for it: what is drawn over the mine is what is clicked\n\t\t\tconst under = world.get(target.on)\n\t\t\tif (under?.get(deposit) && canHarvest(world, entity, under)) return { type: 'harvest', target: under.id }\n\t\t\tif (target.def.dropOff && target.owner === entity.owner && target.operational && harvester.carrying > 0) return { type: 'return' }\n\t\t}\n\t\tif (\n\t\t\tentity.def.builds?.length &&\n\t\t\ttarget.has(constructionSite) &&\n\t\t\tconstructionOf(target.def) === 'builder' &&\n\t\t\tworld.areAllies(entity.owner, target.owner)\n\t\t) {\n\t\t\treturn { type: 'construct', target: target.id }\n\t\t}\n\t\tif (entity.def.builds?.length && canRepair(world, entity.owner, target)) return { type: 'repair', target: target.id }\n\t\tif (world.areEnemies(entity.owner, target.owner)) return { type: 'move', point: { x: target.pos.x, z: target.pos.z } }\n\t\t// a transport of their side with room: in they get\n\t\tif (target.def.transport && canBoard(world, entity, target)) return { type: 'board', target: target.id }\n\t\t// a transport clicking one of its side's that can get in: it goes and takes it in\n\t\tif (entity.def.transport && canBoard(world, target, entity)) return { type: 'load', target: target.id }\n\t\t// friends that walk are stayed with, everything else is walked up to\n\t\tif (target.get(moving) && world.areAllies(entity.owner, target.owner)) return { type: 'follow', target: target.id }\n\t\treturn { type: 'move', target: target.id }\n\t}\n\treturn { type: 'move', point }\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,WAAW,OAAc,QAAgB,OAAa,QAAwC;CAC7G,IAAI,CAAC,OAAO,IAAI,MAAM,GAAG,OAAO,KAAA;CAChC,IAAI,UAAU,WAAW,QAAQ;EAChC,IAAI,UAAU,OAAO,QAAQ,MAAM,GAAG,OAAO;GAAE,MAAM;GAAU,QAAQ,OAAO;EAAG;EAEjF,IAAI,OAAO,IAAI,YAAY,OAAO,IAAI,SAAS,MAAM,WAAW,OAAO,SAAS,OAAO,MAAM,GAAG,OAAO;GAAE,MAAM;GAAgB,QAAQ,OAAO;EAAG;EACjJ,MAAM,YAAY,YAAY,MAAM;EACpC,IAAI,WAAW;GACd,IAAI,OAAO,IAAI,OAAO,GAAG,OAAO;IAAE,MAAM;IAAW,QAAQ,OAAO;GAAG;GAErE,MAAM,QAAQ,MAAM,IAAI,OAAO,EAAE;GACjC,IAAI,OAAO,IAAI,OAAO,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG,OAAO;IAAE,MAAM;IAAW,QAAQ,MAAM;GAAG;GACxG,IAAI,OAAO,IAAI,WAAW,OAAO,UAAU,OAAO,SAAS,OAAO,eAAe,UAAU,WAAW,GAAG,OAAO,EAAE,MAAM,SAAS;EAClI;EACA,IACC,OAAO,IAAI,QAAQ,UACnB,OAAO,IAAI,gBAAgB,KAC3B,eAAe,OAAO,GAAG,MAAM,aAC/B,MAAM,UAAU,OAAO,OAAO,OAAO,KAAK,GAE1C,OAAO;GAAE,MAAM;GAAa,QAAQ,OAAO;EAAG;EAE/C,IAAI,OAAO,IAAI,QAAQ,UAAU,UAAU,OAAO,OAAO,OAAO,MAAM,GAAG,OAAO;GAAE,MAAM;GAAU,QAAQ,OAAO;EAAG;EACpH,IAAI,MAAM,WAAW,OAAO,OAAO,OAAO,KAAK,GAAG,OAAO;GAAE,MAAM;GAAQ,OAAO;IAAE,GAAG,OAAO,IAAI;IAAG,GAAG,OAAO,IAAI;GAAE;EAAE;EAErH,IAAI,OAAO,IAAI,aAAa,SAAS,OAAO,QAAQ,MAAM,GAAG,OAAO;GAAE,MAAM;GAAS,QAAQ,OAAO;EAAG;EAEvG,IAAI,OAAO,IAAI,aAAa,SAAS,OAAO,QAAQ,MAAM,GAAG,OAAO;GAAE,MAAM;GAAQ,QAAQ,OAAO;EAAG;EAEtG,IAAI,OAAO,IAAI,MAAM,KAAK,MAAM,UAAU,OAAO,OAAO,OAAO,KAAK,GAAG,OAAO;GAAE,MAAM;GAAU,QAAQ,OAAO;EAAG;EAClH,OAAO;GAAE,MAAM;GAAQ,QAAQ,OAAO;EAAG;CAC1C;CACA,OAAO;EAAE,MAAM;EAAQ;CAAM;AAC9B"}

package/dist/spatial.d.ts

@@ -1,18 +1,4 @@
 import type { Entity, PlayerId } from './entity';
-/**
- * Uniform grid for "what is near this point" queries. The map is cut into square cells and every entity is
- * filed under the cells it is in, so a query only looks at the few cells around the point instead of at every
- * entity in the world.
- *
- * There are two layers:
- * - Units move, so they are filed again from scratch every tick (`rebuild`), which is simpler and cheaper than
- *   following every unit from cell to cell. A unit is filed by its center only, so queries look a little
- *   further than asked, by the radius of the biggest unit, not to miss one whose edge is in range.
- * - Structures (buildings, trees, mines) never move, so they are filed once when they appear and taken out when
- *   they go (`insertStatic`, `removeStatic`). They are filed under every cell their footprint covers, so a query
- *   finds them by any part of them without looking further than asked. That matters: padding queries by the
- *   size of the biggest building would make every query near a forest go through far more trees.
- */
 export declare class SpatialIndex {
     private readonly cellSize;
     private readonly cols;
@@ -25,16 +11,38 @@ export declare class SpatialIndex {
      * since (`ownerChanged`), until the next filing
      */
     private readonly soleOwner;
+    /** By cell, how many units were filed in it so far this filing (`rebuild`) */
+    private readonly filed;
     private ownersMoved;
     /** Radius of the biggest unit filed this tick */
     private maxRadius;
+    /** Radius of the biggest unit filed this tick that is not big (`BIG_RADIUS`) */
+    private maxSmallRadius;
+    /**
+     * The big units filed this tick (they are in `cells` as well), in the order a query finds them: by cell, then
+     * as filed. Each one's cell, column and row alongside. Only up to `MAX_BIG`: `bigCount` counts them all
+     */
+    private readonly big;
+    private readonly bigAt;
+    private readonly bigCol;
+    private readonly bigRow;
+    private bigCount;
+    /** In a query, the first big unit in the list not yet gone by */
+    private bigNext;
     /** Counts queries. A structure that covers several cells is marked with it when found, so it is only found once */
     private stamp;
     constructor(width: number, depth: number, cellSize?: number);
     private col;
     private row;
-    /** Files every unit again. Called once per tick, before the systems run. Structures in `entities` are passed over */
+    /**
+     * Files every unit again. Called once per tick, before the systems run. Structures in `entities` are passed over.
+     *
+     * Each cell is written over from its start and cut to what it got at the end, not emptied first: a list emptied
+     * (`length = 0`) lets go of its room, and filling it again would make it all anew, every cell, every tick
+     */
     rebuild(entities: Iterable<Entity>): void;
+    /** Into the list of big units, after every one in a cell before its own or in the same: as it is in the cells */
+    private fileBig;
     /** A unit filed this tick has another owner now: no cell's one owner is gone by until the next filing */
     ownerChanged(): void;
     /** Files a structure under every cell it covers, for as long as it stands */
@@ -45,7 +53,8 @@ export declare class SpatialIndex {
      * Entities that could be within `radius` of the point: every structure that has a part in the square around it,
      * and every unit whose center is close enough for its edge to be. Callers do the exact distance check.
      *
-     * The answer is written into `out`, which callers keep around and pass again so that nothing is allocated. While going
+     * The answer is written into `out`, which callers keep around and pass again so that nothing is allocated: over what
+     * it held, then cut to the answer (emptied first, a list lets go of its room and grows it again). While going
      * through the answer, a caller that does something which can lead to another query with the same `out` (dealing damage
      * can set off effects that look around) has to go through a copy instead: the other query would overwrite it.
      *
@@ -53,6 +62,13 @@ export declare class SpatialIndex {
      * one such owner alone is left out. What is left is what the full answer had, in the same order, less some of theirs
      */
     query(x: number, z: number, radius: number, out?: Entity[], skip?: (owner: PlayerId) => boolean): Entity[];
+    /**
+     * Adds to a query's answer, from `bigNext` on, the big units in cells before `before` that the cells it goes
+     * through (`minX`..`maxZ`) leave out but that reach within `radius` of the point by their own radius: where they would
+     * have been in an answer that went through more cells. Those in a cell it goes through are found there. Returns how
+     * many the answer has now
+     */
+    private addBigs;
     /**
      * Only the structures that have a part in the square around the point: buildings, trees, mines, every kind but a
      * unit. For who looks for those alone, among crowds of units that would otherwise all be gone through. Into `out`,

package/dist/spatial.js

@@ -0,0 +1,234 @@
+//#region src/spatial.ts
+/**
+* Uniform grid for "what is near this point" queries. The map is cut into square cells and every entity is
+* filed under the cells it is in, so a query only looks at the few cells around the point instead of at every
+* entity in the world.
+*
+* There are two layers:
+* - Units move, so they are filed again from scratch every tick (`rebuild`), which is simpler and cheaper than
+*   following every unit from cell to cell. A unit is filed by its center only, so queries look a little
+*   further than asked, by the radius of the biggest ordinary unit, not to miss one whose edge is in range. The
+*   few units bigger than that (`BIG_RADIUS`: a boss, a siege engine) are kept in a short list besides, which
+*   every query goes through, each looked for as far as its own radius: one of them on the map does not make every
+*   query near a crowd of small ones go through more cells. Above `MAX_BIG` of them, it is not worth it, and
+*   queries look as far as the biggest unit again. Either way an answer is in the same order: by cell, and by
+*   filing within a cell.
+* - Structures (buildings, trees, mines) never move, so they are filed once when they appear and taken out when
+*   they go (`insertStatic`, `removeStatic`). They are filed under every cell their footprint covers, so a query
+*   finds them by any part of them without looking further than asked. That matters: padding queries by the
+*   size of the biggest building would make every query near a forest go through far more trees.
+*/
+/** Units with a bigger radius than this are big: kept besides in a short list, not making every query look further */
+var BIG_RADIUS = 1;
+/** Above so many big units filed in a tick, queries look as far as the biggest one instead, as though there were none */
+var MAX_BIG = 32;
+var SpatialIndex = class {
+	cellSize;
+	cols;
+	rows;
+	cells;
+	staticCells;
+	/**
+	* By cell, the one owner of every unit filed in it this tick, or -1 for none or more than one: what a search that
+	* passes over a side's own leaves out cell by cell (`query`'s `skip`). Not to be gone by once an owner changed
+	* since (`ownerChanged`), until the next filing
+	*/
+	soleOwner;
+	/** By cell, how many units were filed in it so far this filing (`rebuild`) */
+	filed;
+	ownersMoved = false;
+	/** Radius of the biggest unit filed this tick */
+	maxRadius = 0;
+	/** Radius of the biggest unit filed this tick that is not big (`BIG_RADIUS`) */
+	maxSmallRadius = 0;
+	/**
+	* The big units filed this tick (they are in `cells` as well), in the order a query finds them: by cell, then
+	* as filed. Each one's cell, column and row alongside. Only up to `MAX_BIG`: `bigCount` counts them all
+	*/
+	big = [];
+	bigAt = new Int32Array(MAX_BIG);
+	bigCol = new Int32Array(MAX_BIG);
+	bigRow = new Int32Array(MAX_BIG);
+	bigCount = 0;
+	/** In a query, the first big unit in the list not yet gone by */
+	bigNext = 0;
+	/** Counts queries. A structure that covers several cells is marked with it when found, so it is only found once */
+	stamp = 0;
+	constructor(width, depth, cellSize = 4) {
+		this.cellSize = cellSize;
+		this.cols = Math.ceil(width / cellSize);
+		this.rows = Math.ceil(depth / cellSize);
+		this.cells = Array.from({ length: this.cols * this.rows }, () => []);
+		this.staticCells = Array.from({ length: this.cols * this.rows }, () => []);
+		this.soleOwner = new Int32Array(this.cols * this.rows).fill(-1);
+		this.filed = new Int32Array(this.cols * this.rows);
+	}
+	col(x) {
+		return Math.min(Math.max(Math.floor(x / this.cellSize), 0), this.cols - 1);
+	}
+	row(z) {
+		return Math.min(Math.max(Math.floor(z / this.cellSize), 0), this.rows - 1);
+	}
+	/**
+	* Files every unit again. Called once per tick, before the systems run. Structures in `entities` are passed over.
+	*
+	* Each cell is written over from its start and cut to what it got at the end, not emptied first: a list emptied
+	* (`length = 0`) lets go of its room, and filling it again would make it all anew, every cell, every tick
+	*/
+	rebuild(entities) {
+		this.maxRadius = 0;
+		this.maxSmallRadius = 0;
+		this.bigCount = 0;
+		this.ownersMoved = false;
+		const sole = this.soleOwner;
+		sole.fill(-1);
+		const filed = this.filed;
+		filed.fill(0);
+		for (const entity of entities) {
+			if (!entity.alive || entity.hidden || entity.isStructure) continue;
+			const at = this.row(entity.pos.z) * this.cols + this.col(entity.pos.x);
+			sole[at] = filed[at] === 0 || sole[at] === entity.owner ? entity.owner : -1;
+			this.cells[at][filed[at]++] = entity;
+			const radius = entity.def.radius;
+			if (radius > this.maxRadius) this.maxRadius = radius;
+			if (radius <= BIG_RADIUS) {
+				if (radius > this.maxSmallRadius) this.maxSmallRadius = radius;
+			} else if (this.bigCount++ < MAX_BIG) this.fileBig(entity, at);
+		}
+		const { cells } = this;
+		for (let i = 0; i < cells.length; i++) if (cells[i].length !== filed[i]) cells[i].length = filed[i];
+		this.big.length = Math.min(this.bigCount, MAX_BIG);
+	}
+	/** Into the list of big units, after every one in a cell before its own or in the same: as it is in the cells */
+	fileBig(entity, at) {
+		const { big, bigAt, bigCol, bigRow } = this;
+		let i = this.bigCount - 1;
+		for (; i > 0 && bigAt[i - 1] > at; i--) {
+			big[i] = big[i - 1];
+			bigAt[i] = bigAt[i - 1];
+			bigCol[i] = bigCol[i - 1];
+			bigRow[i] = bigRow[i - 1];
+		}
+		big[i] = entity;
+		bigAt[i] = at;
+		bigCol[i] = at % this.cols;
+		bigRow[i] = (at - bigCol[i]) / this.cols;
+	}
+	/** A unit filed this tick has another owner now: no cell's one owner is gone by until the next filing */
+	ownerChanged() {
+		this.ownersMoved = true;
+	}
+	/** Files a structure under every cell it covers, for as long as it stands */
+	insertStatic(entity) {
+		this.forCellsOf(entity, (cell) => cell.push(entity));
+	}
+	removeStatic(entity) {
+		this.forCellsOf(entity, (cell) => {
+			const index = cell.indexOf(entity);
+			if (index < 0) return;
+			cell.splice(index, 1);
+		});
+	}
+	forCellsOf(entity, fn) {
+		const { x, z, hw, hd } = entity.rect;
+		const maxX = this.col(x + hw);
+		const maxZ = this.row(z + hd);
+		for (let cz = this.row(z - hd); cz <= maxZ; cz++) for (let cx = this.col(x - hw); cx <= maxX; cx++) fn(this.staticCells[cz * this.cols + cx]);
+	}
+	/**
+	* Entities that could be within `radius` of the point: every structure that has a part in the square around it,
+	* and every unit whose center is close enough for its edge to be. Callers do the exact distance check.
+	*
+	* The answer is written into `out`, which callers keep around and pass again so that nothing is allocated: over what
+	* it held, then cut to the answer (emptied first, a list lets go of its room and grows it again). While going
+	* through the answer, a caller that does something which can lead to another query with the same `out` (dealing damage
+	* can set off effects that look around) has to go through a copy instead: the other query would overwrite it.
+	*
+	* `skip`: owners whose units the caller passes over anyway (a side's own, as it picks a target): a cell of units of
+	* one such owner alone is left out. What is left is what the full answer had, in the same order, less some of theirs
+	*/
+	query(x, z, radius, out = [], skip) {
+		let found = 0;
+		const stamp = ++this.stamp;
+		const sole = skip && !this.ownersMoved ? this.soleOwner : void 0;
+		const bigs = this.bigCount <= MAX_BIG ? this.bigCount : 0;
+		let r = radius + (bigs ? this.maxSmallRadius : this.maxRadius);
+		const minX = this.col(x - r);
+		const minZ = this.row(z - r);
+		let maxX = this.col(x + r);
+		let maxZ = this.row(z + r);
+		this.bigNext = 0;
+		for (let cz = minZ; cz <= maxZ; cz++) for (let cx = minX; cx <= maxX; cx++) {
+			const at = cz * this.cols + cx;
+			if (this.bigNext < bigs && this.bigAt[this.bigNext] < at) found = this.addBigs(x, z, radius, minX, maxX, minZ, maxZ, at, out, found, skip);
+			if (sole && sole[at] >= 0 && skip(sole[at])) continue;
+			const cell = this.cells[at];
+			for (let i = 0; i < cell.length; i++) out[found++] = cell[i];
+		}
+		if (this.bigNext < bigs) found = this.addBigs(x, z, radius, minX, maxX, minZ, maxZ, Infinity, out, found, skip);
+		r = radius;
+		maxX = this.col(x + r);
+		maxZ = this.row(z + r);
+		for (let cz = this.row(z - r); cz <= maxZ; cz++) for (let cx = this.col(x - r); cx <= maxX; cx++) {
+			const cell = this.staticCells[cz * this.cols + cx];
+			for (let i = 0; i < cell.length; i++) {
+				const entity = cell[i];
+				if (entity.spatialStamp === stamp) continue;
+				entity.spatialStamp = stamp;
+				out[found++] = entity;
+			}
+		}
+		out.length = found;
+		return out;
+	}
+	/**
+	* Adds to a query's answer, from `bigNext` on, the big units in cells before `before` that the cells it goes
+	* through (`minX`..`maxZ`) leave out but that reach within `radius` of the point by their own radius: where they would
+	* have been in an answer that went through more cells. Those in a cell it goes through are found there. Returns how
+	* many the answer has now
+	*/
+	addBigs(x, z, radius, minX, maxX, minZ, maxZ, before, out, found, skip) {
+		const { big, bigAt, bigCol, bigRow, soleOwner } = this;
+		const sole = skip && !this.ownersMoved ? soleOwner : void 0;
+		const count = Math.min(this.bigCount, MAX_BIG);
+		let i = this.bigNext;
+		for (; i < count && bigAt[i] < before; i++) {
+			const cx = bigCol[i];
+			const cz = bigRow[i];
+			if (cx >= minX && cx <= maxX && cz >= minZ && cz <= maxZ) continue;
+			const r = radius + big[i].def.radius;
+			if (cx < this.col(x - r) || cx > this.col(x + r) || cz < this.row(z - r) || cz > this.row(z + r)) continue;
+			const at = bigAt[i];
+			if (sole && sole[at] >= 0 && skip(sole[at])) continue;
+			out[found++] = big[i];
+		}
+		this.bigNext = i;
+		return found;
+	}
+	/**
+	* Only the structures that have a part in the square around the point: buildings, trees, mines, every kind but a
+	* unit. For who looks for those alone, among crowds of units that would otherwise all be gone through. Into `out`,
+	* as `query`
+	*/
+	queryStatic(x, z, radius, out = []) {
+		let found = 0;
+		const stamp = ++this.stamp;
+		const maxX = this.col(x + radius);
+		const maxZ = this.row(z + radius);
+		for (let cz = this.row(z - radius); cz <= maxZ; cz++) for (let cx = this.col(x - radius); cx <= maxX; cx++) {
+			const cell = this.staticCells[cz * this.cols + cx];
+			for (let i = 0; i < cell.length; i++) {
+				const entity = cell[i];
+				if (entity.spatialStamp === stamp) continue;
+				entity.spatialStamp = stamp;
+				out[found++] = entity;
+			}
+		}
+		out.length = found;
+		return out;
+	}
+};
+//#endregion
+export { SpatialIndex };
+
+//# sourceMappingURL=spatial.js.map

package/dist/spatial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial.js","names":[],"sources":["../src/spatial.ts"],"sourcesContent":["import type { Entity, PlayerId } from './entity'\n\n/**\n * Uniform grid for \"what is near this point\" queries. The map is cut into square cells and every entity is\n * filed under the cells it is in, so a query only looks at the few cells around the point instead of at every\n * entity in the world.\n *\n * There are two layers:\n * - Units move, so they are filed again from scratch every tick (`rebuild`), which is simpler and cheaper than\n *   following every unit from cell to cell. A unit is filed by its center only, so queries look a little\n *   further than asked, by the radius of the biggest ordinary unit, not to miss one whose edge is in range. The\n *   few units bigger than that (`BIG_RADIUS`: a boss, a siege engine) are kept in a short list besides, which\n *   every query goes through, each looked for as far as its own radius: one of them on the map does not make every\n *   query near a crowd of small ones go through more cells. Above `MAX_BIG` of them, it is not worth it, and\n *   queries look as far as the biggest unit again. Either way an answer is in the same order: by cell, and by\n *   filing within a cell.\n * - Structures (buildings, trees, mines) never move, so they are filed once when they appear and taken out when\n *   they go (`insertStatic`, `removeStatic`). They are filed under every cell their footprint covers, so a query\n *   finds them by any part of them without looking further than asked. That matters: padding queries by the\n *   size of the biggest building would make every query near a forest go through far more trees.\n */\n/** Units with a bigger radius than this are big: kept besides in a short list, not making every query look further */\nconst BIG_RADIUS = 1\n/** Above so many big units filed in a tick, queries look as far as the biggest one instead, as though there were none */\nconst MAX_BIG = 32\n\nexport class SpatialIndex {\n\tprivate readonly cols: number\n\tprivate readonly rows: number\n\tprivate readonly cells: Entity[][]\n\tprivate readonly staticCells: Entity[][]\n\t/**\n\t * By cell, the one owner of every unit filed in it this tick, or -1 for none or more than one: what a search that\n\t * passes over a side's own leaves out cell by cell (`query`'s `skip`). Not to be gone by once an owner changed\n\t * since (`ownerChanged`), until the next filing\n\t */\n\tprivate readonly soleOwner: Int32Array\n\t/** By cell, how many units were filed in it so far this filing (`rebuild`) */\n\tprivate readonly filed: Int32Array\n\tprivate ownersMoved = false\n\t/** Radius of the biggest unit filed this tick */\n\tprivate maxRadius = 0\n\t/** Radius of the biggest unit filed this tick that is not big (`BIG_RADIUS`) */\n\tprivate maxSmallRadius = 0\n\t/**\n\t * The big units filed this tick (they are in `cells` as well), in the order a query finds them: by cell, then\n\t * as filed. Each one's cell, column and row alongside. Only up to `MAX_BIG`: `bigCount` counts them all\n\t */\n\tprivate readonly big: Entity[] = []\n\tprivate readonly bigAt = new Int32Array(MAX_BIG)\n\tprivate readonly bigCol = new Int32Array(MAX_BIG)\n\tprivate readonly bigRow = new Int32Array(MAX_BIG)\n\tprivate bigCount = 0\n\t/** In a query, the first big unit in the list not yet gone by */\n\tprivate bigNext = 0\n\t/** Counts queries. A structure that covers several cells is marked with it when found, so it is only found once */\n\tprivate stamp = 0\n\n\tconstructor(\n\t\twidth: number,\n\t\tdepth: number,\n\t\tprivate readonly cellSize = 4\n\t) {\n\t\tthis.cols = Math.ceil(width / cellSize)\n\t\tthis.rows = Math.ceil(depth / cellSize)\n\t\tthis.cells = Array.from({ length: this.cols * this.rows }, () => [])\n\t\tthis.staticCells = Array.from({ length: this.cols * this.rows }, () => [])\n\t\tthis.soleOwner = new Int32Array(this.cols * this.rows).fill(-1)\n\t\tthis.filed = new Int32Array(this.cols * this.rows)\n\t}\n\n\tprivate col(x: number): number {\n\t\treturn Math.min(Math.max(Math.floor(x / this.cellSize), 0), this.cols - 1)\n\t}\n\n\tprivate row(z: number): number {\n\t\treturn Math.min(Math.max(Math.floor(z / this.cellSize), 0), this.rows - 1)\n\t}\n\n\t/**\n\t * Files every unit again. Called once per tick, before the systems run. Structures in `entities` are passed over.\n\t *\n\t * Each cell is written over from its start and cut to what it got at the end, not emptied first: a list emptied\n\t * (`length = 0`) lets go of its room, and filling it again would make it all anew, every cell, every tick\n\t */\n\trebuild(entities: Iterable<Entity>): void {\n\t\tthis.maxRadius = 0\n\t\tthis.maxSmallRadius = 0\n\t\tthis.bigCount = 0\n\t\tthis.ownersMoved = false\n\t\tconst sole = this.soleOwner\n\t\tsole.fill(-1)\n\t\tconst filed = this.filed\n\t\tfiled.fill(0)\n\t\tfor (const entity of entities) {\n\t\t\tif (!entity.alive || entity.hidden || entity.isStructure) continue\n\t\t\tconst at = this.row(entity.pos.z) * this.cols + this.col(entity.pos.x)\n\t\t\tsole[at] = filed[at] === 0 || sole[at] === entity.owner ? entity.owner : -1\n\t\t\tthis.cells[at][filed[at]++] = entity\n\t\t\tconst radius = entity.def.radius\n\t\t\tif (radius > this.maxRadius) this.maxRadius = radius\n\t\t\tif (radius <= BIG_RADIUS) {\n\t\t\t\tif (radius > this.maxSmallRadius) this.maxSmallRadius = radius\n\t\t\t} else if (this.bigCount++ < MAX_BIG) this.fileBig(entity, at)\n\t\t}\n\t\tconst { cells } = this\n\t\tfor (let i = 0; i < cells.length; i++) if (cells[i].length !== filed[i]) cells[i].length = filed[i]\n\t\tthis.big.length = Math.min(this.bigCount, MAX_BIG)\n\t}\n\n\t/** Into the list of big units, after every one in a cell before its own or in the same: as it is in the cells */\n\tprivate fileBig(entity: Entity, at: number): void {\n\t\tconst { big, bigAt, bigCol, bigRow } = this\n\t\tlet i = this.bigCount - 1\n\t\tfor (; i > 0 && bigAt[i - 1] > at; i--) {\n\t\t\tbig[i] = big[i - 1]\n\t\t\tbigAt[i] = bigAt[i - 1]\n\t\t\tbigCol[i] = bigCol[i - 1]\n\t\t\tbigRow[i] = bigRow[i - 1]\n\t\t}\n\t\tbig[i] = entity\n\t\tbigAt[i] = at\n\t\tbigCol[i] = at % this.cols\n\t\tbigRow[i] = (at - bigCol[i]) / this.cols\n\t}\n\n\t/** A unit filed this tick has another owner now: no cell's one owner is gone by until the next filing */\n\townerChanged(): void {\n\t\tthis.ownersMoved = true\n\t}\n\n\t/** Files a structure under every cell it covers, for as long as it stands */\n\tinsertStatic(entity: Entity): void {\n\t\tthis.forCellsOf(entity, (cell) => cell.push(entity))\n\t}\n\n\tremoveStatic(entity: Entity): void {\n\t\tthis.forCellsOf(entity, (cell) => {\n\t\t\tconst index = cell.indexOf(entity)\n\t\t\tif (index < 0) return\n\t\t\t// the others keep their order (insertion order, which a load restores): ties between targets break by it\n\t\t\tcell.splice(index, 1)\n\t\t})\n\t}\n\n\tprivate forCellsOf(entity: Entity, fn: (cell: Entity[]) => void): void {\n\t\tconst { x, z, hw, hd } = entity.rect\n\t\tconst maxX = this.col(x + hw)\n\t\tconst maxZ = this.row(z + hd)\n\t\tfor (let cz = this.row(z - hd); cz <= maxZ; cz++) {\n\t\t\tfor (let cx = this.col(x - hw); cx <= maxX; cx++) fn(this.staticCells[cz * this.cols + cx])\n\t\t}\n\t}\n\n\t/**\n\t * Entities that could be within `radius` of the point: every structure that has a part in the square around it,\n\t * and every unit whose center is close enough for its edge to be. Callers do the exact distance check.\n\t *\n\t * The answer is written into `out`, which callers keep around and pass again so that nothing is allocated: over what\n\t * it held, then cut to the answer (emptied first, a list lets go of its room and grows it again). While going\n\t * through the answer, a caller that does something which can lead to another query with the same `out` (dealing damage\n\t * can set off effects that look around) has to go through a copy instead: the other query would overwrite it.\n\t *\n\t * `skip`: owners whose units the caller passes over anyway (a side's own, as it picks a target): a cell of units of\n\t * one such owner alone is left out. What is left is what the full answer had, in the same order, less some of theirs\n\t */\n\tquery(x: number, z: number, radius: number, out: Entity[] = [], skip?: (owner: PlayerId) => boolean): Entity[] {\n\t\tlet found = 0\n\t\tconst stamp = ++this.stamp\n\t\tconst sole = skip && !this.ownersMoved ? this.soleOwner : undefined\n\n\t\t// a few big units: the cells as far as the biggest of the others, and the big ones each as far as its own radius,\n\t\t// found among them in the cells' order. Many: as far as the biggest of all\n\t\tconst bigs = this.bigCount <= MAX_BIG ? this.bigCount : 0\n\t\tlet r = radius + (bigs ? this.maxSmallRadius : this.maxRadius)\n\t\tconst minX = this.col(x - r)\n\t\tconst minZ = this.row(z - r)\n\t\tlet maxX = this.col(x + r)\n\t\tlet maxZ = this.row(z + r)\n\t\tthis.bigNext = 0\n\t\tfor (let cz = minZ; cz <= maxZ; cz++) {\n\t\t\tfor (let cx = minX; cx <= maxX; cx++) {\n\t\t\t\tconst at = cz * this.cols + cx\n\t\t\t\tif (this.bigNext < bigs && this.bigAt[this.bigNext] < at) found = this.addBigs(x, z, radius, minX, maxX, minZ, maxZ, at, out, found, skip)\n\t\t\t\tif (sole && sole[at] >= 0 && skip!(sole[at])) continue\n\t\t\t\tconst cell = this.cells[at]\n\t\t\t\tfor (let i = 0; i < cell.length; i++) out[found++] = cell[i]\n\t\t\t}\n\t\t}\n\t\tif (this.bigNext < bigs) found = this.addBigs(x, z, radius, minX, maxX, minZ, maxZ, Infinity, out, found, skip)\n\n\t\tr = radius\n\t\tmaxX = this.col(x + r)\n\t\tmaxZ = this.row(z + r)\n\t\tfor (let cz = this.row(z - r); cz <= maxZ; cz++) {\n\t\t\tfor (let cx = this.col(x - r); cx <= maxX; cx++) {\n\t\t\t\tconst cell = this.staticCells[cz * this.cols + cx]\n\t\t\t\tfor (let i = 0; i < cell.length; i++) {\n\t\t\t\t\tconst entity = cell[i]\n\t\t\t\t\tif (entity.spatialStamp === stamp) continue\n\t\t\t\t\tentity.spatialStamp = stamp\n\t\t\t\t\tout[found++] = entity\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tout.length = found\n\t\treturn out\n\t}\n\n\t/**\n\t * Adds to a query's answer, from `bigNext` on, the big units in cells before `before` that the cells it goes\n\t * through (`minX`..`maxZ`) leave out but that reach within `radius` of the point by their own radius: where they would\n\t * have been in an answer that went through more cells. Those in a cell it goes through are found there. Returns how\n\t * many the answer has now\n\t */\n\tprivate addBigs(\n\t\tx: number,\n\t\tz: number,\n\t\tradius: number,\n\t\tminX: number,\n\t\tmaxX: number,\n\t\tminZ: number,\n\t\tmaxZ: number,\n\t\tbefore: number,\n\t\tout: Entity[],\n\t\tfound: number,\n\t\tskip: ((owner: PlayerId) => boolean) | undefined\n\t): number {\n\t\tconst { big, bigAt, bigCol, bigRow, soleOwner } = this\n\t\tconst sole = skip && !this.ownersMoved ? soleOwner : undefined\n\t\tconst count = Math.min(this.bigCount, MAX_BIG)\n\t\tlet i = this.bigNext\n\t\tfor (; i < count && bigAt[i] < before; i++) {\n\t\t\tconst cx = bigCol[i]\n\t\t\tconst cz = bigRow[i]\n\t\t\tif (cx >= minX && cx <= maxX && cz >= minZ && cz <= maxZ) continue\n\t\t\tconst r = radius + big[i].def.radius\n\t\t\tif (cx < this.col(x - r) || cx > this.col(x + r) || cz < this.row(z - r) || cz > this.row(z + r)) continue\n\t\t\tconst at = bigAt[i]\n\t\t\tif (sole && sole[at] >= 0 && skip!(sole[at])) continue\n\t\t\tout[found++] = big[i]\n\t\t}\n\t\tthis.bigNext = i\n\t\treturn found\n\t}\n\n\t/**\n\t * Only the structures that have a part in the square around the point: buildings, trees, mines, every kind but a\n\t * unit. For who looks for those alone, among crowds of units that would otherwise all be gone through. Into `out`,\n\t * as `query`\n\t */\n\tqueryStatic(x: number, z: number, radius: number, out: Entity[] = []): Entity[] {\n\t\tlet found = 0\n\t\tconst stamp = ++this.stamp\n\t\tconst maxX = this.col(x + radius)\n\t\tconst maxZ = this.row(z + radius)\n\t\tfor (let cz = this.row(z - radius); cz <= maxZ; cz++) {\n\t\t\tfor (let cx = this.col(x - radius); cx <= maxX; cx++) {\n\t\t\t\tconst cell = this.staticCells[cz * this.cols + cx]\n\t\t\t\tfor (let i = 0; i < cell.length; i++) {\n\t\t\t\t\tconst entity = cell[i]\n\t\t\t\t\tif (entity.spatialStamp === stamp) continue\n\t\t\t\t\tentity.spatialStamp = stamp\n\t\t\t\t\tout[found++] = entity\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tout.length = found\n\t\treturn out\n\t}\n}\n"],"mappings":"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"}

package/dist/spawning.d.ts

@@ -13,6 +13,7 @@ export declare class Spawning {
     /**
      * Turns scenery into an actor, for good: something gave it a reason to be looked at every tick, like a buff
      * that has to run out. Whatever does that to an entity calls this.world; the debug checks catch what forgets to.
+     * It joins `World.units` at the end, out of id order (see `World.units`), which a save keeps as it is
      */
     wake(entity: Entity): void;
     /** Puts a unit somewhere else, where it stands: the way through is not its concern. Structures stay where they were built */