@v12-engine/engine 0.1.0 → 0.4.0

package/dist/effects.js

@@ -0,0 +1,110 @@
+import { defineComponent } from "./components.js";
+import { fxStarted, fxStopped } from "./engineEvents.js";
+import { replicateEvent } from "./replication.js";
+import { plain } from "./plain.js";
+//#region src/effects.ts
+/** A number from a tick and a count, the same wherever the game runs */
+var seedOf = (tick, count) => {
+	let h = Math.imul(tick ^ 2654435769, 2246822507) ^ Math.imul(count + 1, 3266489909);
+	h = Math.imul(h ^ h >>> 16, 2146121005);
+	return (h ^ h >>> 15) >>> 0;
+};
+/**
+* How many effects a world played, for their ids and their seeds: the world's, and saved with it, so that the game
+* loaded from a save gives its next effect the id and the seed the game that went on does (and a stop finds its start)
+*/
+var played = defineComponent({
+	id: "core.effectsPlayed",
+	default: () => 0
+});
+/**
+* Plays one of the view's effects on the screens of the players who see where it is (or those it is for), now. What it
+* gives back stops it (`stopFx`). Not in the world's state but for its count: a save, and a player who joins later,
+* know nothing of the effect itself
+*
+* @beta
+*/
+function playFx(world, effect, options = {}) {
+	const count = world.state(played) + 1;
+	world.setState(played, count);
+	const { at, on, point, params, seed, to = "everyone", overFog, toward } = options;
+	const entity = typeof on === "number" ? world.get(on) : on;
+	if (on !== void 0 && !entity) return count;
+	const other = typeof toward === "number" ? world.get(toward) : toward && "pos" in toward ? toward : void 0;
+	if (typeof toward === "number" && !other) return count;
+	const cue = {
+		id: count,
+		effect,
+		seed: seed ?? seedOf(world.tick, count),
+		...entity ? {
+			on: entity.id,
+			x: entity.pos.x,
+			z: entity.pos.z
+		} : at && {
+			x: at.x,
+			z: at.z,
+			..."y" in at && { y: at.y }
+		},
+		...point && { point },
+		...params && { params: plain(params, `params of the effect "${effect}"`, "FxOptions") },
+		...to !== "everyone" && { to: Array.isArray(to) ? to : [to] },
+		...overFog && { overFog },
+		...other ? { toward: other.id } : toward && {
+			tx: toward.x,
+			tz: toward.z
+		}
+	};
+	world.events.emit(fxStarted, cue);
+	return count;
+}
+/**
+* Stops an effect the rules played (`playFx`), on every screen: as its own `stop` says, over `fade` seconds
+*
+* @beta
+*/
+function stopFx(world, id, options = {}) {
+	world.events.emit(fxStopped, {
+		id,
+		...options.fade !== void 0 && { fade: options.fade }
+	});
+}
+/** The effects of the rules a seat was shown, by id, for a stop to be told to whom saw the start: the latest so many */
+var SHOWN = {};
+/**
+* The effects of the rules a seat was shown (`LocalSession.keptEffects`)
+*
+* @internal
+*/
+var shownFx = (view) => view.keep(SHOWN, () => /* @__PURE__ */ new Set());
+/** An effect the rules play: to whom it is for, who sees where it is (what is there to be noticed, over the fog) */
+var toldFx = replicateEvent(fxStarted, "fx", ({ id, effect, to, overFog, on, toward, ...rest }, view) => {
+	if (to && !to.includes(view.player)) return void 0;
+	const entity = on === void 0 ? void 0 : view.world.get(on);
+	const other = toward === void 0 ? void 0 : view.world.get(toward);
+	const seenEnd = (one) => !!one && (view.knows(one) || !!overFog && !one.hidden);
+	const seen = entity ? seenEnd(entity) : rest.x === void 0 || overFog || view.sees(rest.x, rest.z);
+	const seenOther = other ? seenEnd(other) : rest.tx !== void 0 && (overFog || view.sees(rest.tx, rest.tz));
+	if (!seen && !seenOther) return void 0;
+	const shown = shownFx(view);
+	shown.add(id);
+	if (shown.size > view.mostEffects) shown.delete(shown.values().next().value);
+	return {
+		type: "fx",
+		id,
+		fx: effect,
+		...rest,
+		...on !== void 0 && { on },
+		...overFog && { overFog },
+		...other && view.knows(other) && { toward: other.id }
+	};
+});
+/** An effect stopped: to whom saw it start */
+var toldFxStopped = replicateEvent(fxStopped, "fxStop", ({ id, fade }, view) => shownFx(view).delete(id) ? {
+	type: "fxStop",
+	id,
+	...fade !== void 0 && { fade }
+} : void 0);
+//#endregion
+export { playFx, played, shownFx, stopFx, toldFx, toldFxStopped };
+
+//# sourceMappingURL=effects.js.map

package/dist/effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.js","names":[],"sources":["../src/effects.ts"],"sourcesContent":["import { fxStarted, fxStopped } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport type { Audience } from './dialog'\nimport type { Entity, PlayerId } from './entity'\nimport type { Vec2 } from './math'\nimport { plain } from './plain'\nimport type { World } from './world'\nimport { replicateEvent } from './replication'\nimport type { SessionView } from './replication'\n\n/*\n * Effects are the screen's: fire, a blast, a glow, made and tuned in a game's view (`GameView.fx.defs`). The rules say when\n * one plays, and where, so that every player who sees the place sees it at the same moment (effects plan A3): a mine\n * going off, a shrine waking. Nothing an effect does decides anything in the game; it is not in the world's state, nor\n * in a save. What lasts is shown by what the world keeps (a building's damaged look, a map's own effects)\n */\n\n/**\n * An effect the rules play on the screens, as the engine's `effect` event carries it (`world.fx`)\n *\n * @beta\n */\nexport interface FxCue {\n\t/** The rules' handle on it, for `world.stopFx` */\n\tid: number\n\t/** Which of the view's effects, by name (`GameView.fx.defs`) */\n\teffect: string\n\t/** Where: a place, at a height or on the ground */\n\tx?: number\n\t/** The height it is at; on the ground when left out */\n\ty?: number\n\t/** The north-south place, in cells */\n\tz?: number\n\t/** Or on an entity, by its id: it follows it on the screen, at a point of its model */\n\ton?: number\n\t/** The point of the entity's model it follows, by name; the entity's middle when left out */\n\tpoint?: string\n\t/** Its knobs, over the effect's own: plain data, as it goes to every screen */\n\tparams?: Record<string, unknown>\n\t/** What its random parts go by: the same on every screen */\n\tseed: number\n\t/** Who sees it: everyone who sees the place when left out */\n\tto?: PlayerId[]\n\t/** Seen over the fog of war, by whom it is for: what is there to be noticed */\n\toverFog?: boolean\n\t/** The other end of one drawn between two (`FxOptions.toward`): an entity by its id */\n\ttoward?: number\n\t/** Or a place, east-west */\n\ttx?: number\n\t/** And north-south */\n\ttz?: number\n}\n\n/**\n * How the rules play an effect (`world.fx`)\n *\n * @beta\n */\nexport interface FxOptions {\n\t/** A place: on the ground (`{ x, z }`) or at a height (`{ x, y, z }`) */\n\tat?: Vec2 | { x: number; y: number; z: number }\n\t/** Or an entity: on the screen it follows it, and ends with it */\n\ton?: Entity | number\n\t/** A point of the entity's model (`ModelDef.points`) */\n\tpoint?: string\n\t/** Its knobs, over the effect's own (`EffectDef.params`): plain data */\n\tparams?: Record<string, unknown>\n\t/** What its random parts go by: one made from the tick when left out, the same on every screen all the same */\n\tseed?: number\n\t/** Who sees it: a player, some, or everyone who sees the place (when left out) */\n\tto?: Audience\n\t/** Seen over the fog of war by whom it is for, as what is there to be noticed. No when left out */\n\toverFog?: boolean\n\t/**\n\t * The other end, for an effect drawn between two (a beam, a tether, a link of a chain: the client's `linkFx`): an\n\t * entity it follows on the screen, or a place. It starts at `at` or `on`; seen by whoever sees either end\n\t *\n\t * @beta\n\t */\n\ttoward?: Entity | number | Vec2\n}\n\n/** A number from a tick and a count, the same wherever the game runs */\nconst seedOf = (tick: number, count: number): number => {\n\tlet h = Math.imul(tick ^ 0x9e3779b9, 0x85ebca6b) ^ Math.imul(count + 1, 0xc2b2ae35)\n\th = Math.imul(h ^ (h >>> 16), 0x7feb352d)\n\treturn (h ^ (h >>> 15)) >>> 0\n}\n\n/**\n * How many effects a world played, for their ids and their seeds: the world's, and saved with it, so that the game\n * loaded from a save gives its next effect the id and the seed the game that went on does (and a stop finds its start)\n */\nexport const played = defineComponent<number>({ id: 'core.effectsPlayed', default: () => 0 })\n\n/**\n * Plays one of the view's effects on the screens of the players who see where it is (or those it is for), now. What it\n * gives back stops it (`stopFx`). Not in the world's state but for its count: a save, and a player who joins later,\n * know nothing of the effect itself\n *\n * @beta\n */\nexport function playFx(world: World, effect: string, options: FxOptions = {}): number {\n\tconst count = world.state(played) + 1\n\tworld.setState(played, count)\n\tconst { at, on, point, params, seed, to = 'everyone', overFog, toward } = options\n\tconst entity = typeof on === 'number' ? world.get(on) : on\n\tif (on !== undefined && !entity) return count\n\tconst other = typeof toward === 'number' ? world.get(toward) : toward && 'pos' in toward ? (toward as Entity) : undefined\n\tif (typeof toward === 'number' && !other) return count\n\tconst cue: FxCue = {\n\t\tid: count,\n\t\teffect,\n\t\tseed: seed ?? seedOf(world.tick, count),\n\t\t...(entity ? { on: entity.id, x: entity.pos.x, z: entity.pos.z } : at && { x: at.x, z: at.z, ...('y' in at && { y: at.y }) }),\n\t\t...(point && { point }),\n\t\t...(params && { params: plain(params, `params of the effect \"${effect}\"`, 'FxOptions') as Record<string, unknown> }),\n\t\t...(to !== 'everyone' && { to: Array.isArray(to) ? to : [to] }),\n\t\t...(overFog && { overFog }),\n\t\t...(other ? { toward: other.id } : toward && { tx: (toward as Vec2).x, tz: (toward as Vec2).z })\n\t}\n\tworld.events.emit(fxStarted, cue)\n\treturn count\n}\n\n/**\n * Stops an effect the rules played (`playFx`), on every screen: as its own `stop` says, over `fade` seconds\n *\n * @beta\n */\nexport function stopFx(world: World, id: number, options: { fade?: number } = {}): void {\n\tworld.events.emit(fxStopped, { id, ...(options.fade !== undefined && { fade: options.fade }) })\n}\n\n/** The effects of the rules a seat was shown, by id, for a stop to be told to whom saw the start: the latest so many */\nconst SHOWN = {}\n\n/**\n * The effects of the rules a seat was shown (`LocalSession.keptEffects`)\n *\n * @internal\n */\nexport const shownFx = (view: SessionView): Set<number> => view.keep(SHOWN, () => new Set<number>())\n\n/** An effect the rules play: to whom it is for, who sees where it is (what is there to be noticed, over the fog) */\nexport const toldFx = replicateEvent(fxStarted, 'fx', ({ id, effect, to, overFog, on, toward, ...rest }, view) => {\n\tif (to && !to.includes(view.player)) return undefined\n\tconst entity = on === undefined ? undefined : view.world.get(on)\n\tconst other = toward === undefined ? undefined : view.world.get(toward)\n\tconst seenEnd = (one: typeof entity) => !!one && (view.knows(one) || (!!overFog && !one.hidden))\n\tconst seen = entity ? seenEnd(entity) : rest.x === undefined || overFog || view.sees(rest.x, rest.z!)\n\t// one drawn between two: by whoever sees either end\n\tconst seenOther = other ? seenEnd(other) : rest.tx !== undefined && (overFog || view.sees(rest.tx, rest.tz!))\n\tif (!seen && !seenOther) return undefined\n\tconst shown = shownFx(view)\n\tshown.add(id)\n\t// most are never stopped: the oldest are let go of, as a stop that late has nothing left to stop\n\tif (shown.size > view.mostEffects) shown.delete(shown.values().next().value!)\n\treturn {\n\t\ttype: 'fx',\n\t\tid,\n\t\tfx: effect,\n\t\t...rest,\n\t\t...(on !== undefined && { on }),\n\t\t...(overFog && { overFog }),\n\t\t...(other && view.knows(other) && { toward: other.id })\n\t}\n})\n\n/** An effect stopped: to whom saw it start */\nexport const toldFxStopped = replicateEvent(fxStopped, 'fxStop', ({ id, fade }, view) =>\n\tshownFx(view).delete(id) ? { type: 'fxStop', id, ...(fade !== undefined && { fade }) } : undefined\n)\n"],"mappings":"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"}

package/dist/endings.d.ts

@@ -7,7 +7,7 @@ export declare const pauses: import("./components").Component<{
     used: Record<number, number>;
 }>;
 /**
- * How many pauses a player has left (`GameRules.talk.pauses.each`, less what they used)
+ * How many pauses a player has left (`RuleSettings.talk.pauses.each`, less what they used)
  *
  * @beta
  */

package/dist/endings.js

@@ -0,0 +1,78 @@
+import { defineComponent } from "./components.js";
+import { pauseAsked, playerSurrendered } from "./engineEvents.js";
+import { engineMessage } from "./messages.js";
+import { defeat } from "./systems/victory.js";
+//#region src/endings.ts
+/** How many pauses each player has used, by player */
+var pauses = defineComponent({
+	id: "core.pauses",
+	default: () => ({ used: {} })
+});
+/**
+* How many pauses a player has left (`RuleSettings.talk.pauses.each`, less what they used)
+*
+* @beta
+*/
+function pausesLeft(world, player) {
+	return Math.max(0, world.settings.talk.pauses.each - (world.state(pauses).used[player] ?? 0));
+}
+/** Whether a player may give up or pause: one in the game, not out of it, in a game not over */
+function playing(world, player) {
+	const who = world.player(player);
+	return !who.neutral && !who.creeps && !who.defeated && world.winner === null;
+}
+/**
+* A player gives up: out of the game as if beaten, once the game's `beforeSurrender` lets them. The rest of their
+* side plays on; a side with nobody left loses, as the game's own way to win says (`lastTeamStanding` counts one who
+* gave up as one who was in the game)
+*
+* @beta
+*/
+function surrender(world, player) {
+	if (!playing(world, player)) return;
+	const asked = {
+		player,
+		cancelled: false
+	};
+	if (world.hooks.has("beforeSurrender")) world.hooks.run("beforeSurrender", asked);
+	if (asked.cancelled) return world.message(player, asked.reason ?? engineMessage("cannotDoThat"));
+	const who = world.player(player);
+	who.established = true;
+	world.events.emit(playerSurrendered, { player });
+	defeat(world, player);
+	for (const other of world.players.values()) if (other.id !== player && !other.neutral) world.message(other.id, engineMessage("surrendered", { player: who.name }), "info");
+}
+/**
+* A player asks for the game to be paused: one of their pauses (`RuleSettings.talk.pauses.each`), for at most
+* `RuleSettings.talk.pauses.seconds`, once the game's `beforePause` lets them. Whoever runs the world pauses it on the event
+* (`pauseAsked`): a server does; a game played in the page pauses with its menu instead
+*
+* @internal
+*/
+function askPause(world, player) {
+	if (!playing(world, player)) return;
+	const left = pausesLeft(world, player);
+	if (left <= 0) return world.message(player, engineMessage("noPausesLeft"));
+	const asked = {
+		player,
+		left,
+		seconds: world.settings.talk.pauses.seconds,
+		cancelled: false
+	};
+	if (world.hooks.has("beforePause")) world.hooks.run("beforePause", asked);
+	if (asked.cancelled) return world.message(player, asked.reason ?? engineMessage("cannotDoThat"));
+	const { used } = world.state(pauses);
+	world.setState(pauses, { used: {
+		...used,
+		[player]: (used[player] ?? 0) + 1
+	} });
+	world.events.emit(pauseAsked, {
+		player,
+		seconds: Math.max(0, asked.seconds),
+		left: left - 1
+	});
+}
+//#endregion
+export { askPause, pauses, pausesLeft, surrender };
+
+//# sourceMappingURL=endings.js.map

package/dist/endings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endings.js","names":["pauseAskedEvent"],"sources":["../src/endings.ts"],"sourcesContent":["import { pauseAsked as pauseAskedEvent, playerSurrendered } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport type { PlayerId } from './entity'\nimport { type BeforePause, type BeforeSurrender, type Uncancelled } from './hooks'\nimport { engineMessage } from './messages'\nimport { defeat } from './systems/victory'\nimport type { World } from './world'\n\n/*\n * Giving up, and asking for a pause (S53). Giving up is the defeat there already is, reached another way: the player\n * is out, told so, and the others are told who gave up. A pause is asked of whoever runs the world (a server: its host\n * stops stepping it), as the world cannot stop itself and still hear that it is to go on; how many each player has\n * used is kept in the world, so in a save, and the game's hooks decide (`beforeSurrender`, `beforePause`).\n */\n\n/** How many pauses each player has used, by player */\nexport const pauses = defineComponent<{ used: Record<number, number> }>({ id: 'core.pauses', default: () => ({ used: {} }) })\n\n/**\n * How many pauses a player has left (`RuleSettings.talk.pauses.each`, less what they used)\n *\n * @beta\n */\nexport function pausesLeft(world: World, player: PlayerId): number {\n\treturn Math.max(0, world.settings.talk.pauses.each - (world.state(pauses).used[player] ?? 0))\n}\n\n/** Whether a player may give up or pause: one in the game, not out of it, in a game not over */\nfunction playing(world: World, player: PlayerId): boolean {\n\tconst who = world.player(player)\n\treturn !who.neutral && !who.creeps && !who.defeated && world.winner === null\n}\n\n/**\n * A player gives up: out of the game as if beaten, once the game's `beforeSurrender` lets them. The rest of their\n * side plays on; a side with nobody left loses, as the game's own way to win says (`lastTeamStanding` counts one who\n * gave up as one who was in the game)\n *\n * @beta\n */\nexport function surrender(world: World, player: PlayerId): void {\n\tif (!playing(world, player)) return\n\tconst asked: Uncancelled<BeforeSurrender> = { player, cancelled: false }\n\tif (world.hooks.has('beforeSurrender')) world.hooks.run('beforeSurrender', asked)\n\tif (asked.cancelled) return world.message(player, asked.reason ?? engineMessage('cannotDoThat'))\n\tconst who = world.player(player)\n\t// in the game, for the rule of the last side standing: one who never had a building is counted too\n\twho.established = true\n\tworld.events.emit(playerSurrendered, { player })\n\tdefeat(world, player)\n\tfor (const other of world.players.values()) {\n\t\tif (other.id !== player && !other.neutral) world.message(other.id, engineMessage('surrendered', { player: who.name }), 'info')\n\t}\n}\n\n/**\n * A player asks for the game to be paused: one of their pauses (`RuleSettings.talk.pauses.each`), for at most\n * `RuleSettings.talk.pauses.seconds`, once the game's `beforePause` lets them. Whoever runs the world pauses it on the event\n * (`pauseAsked`): a server does; a game played in the page pauses with its menu instead\n *\n * @internal\n */\nexport function askPause(world: World, player: PlayerId): void {\n\tif (!playing(world, player)) return\n\tconst left = pausesLeft(world, player)\n\tif (left <= 0) return world.message(player, engineMessage('noPausesLeft'))\n\tconst asked: Uncancelled<BeforePause> = { player, left, seconds: world.settings.talk.pauses.seconds, cancelled: false }\n\tif (world.hooks.has('beforePause')) world.hooks.run('beforePause', asked)\n\tif (asked.cancelled) return world.message(player, asked.reason ?? engineMessage('cannotDoThat'))\n\tconst { used } = world.state(pauses)\n\tworld.setState(pauses, { used: { ...used, [player]: (used[player] ?? 0) + 1 } })\n\tworld.events.emit(pauseAskedEvent, { player, seconds: Math.max(0, asked.seconds), left: left - 1 })\n}\n"],"mappings":";;;;;;AAgBA,IAAa,SAAS,gBAAkD;CAAE,IAAI;CAAe,gBAAgB,EAAE,MAAM,CAAC,EAAE;AAAG,CAAC;;;;;;AAO5H,SAAgB,WAAW,OAAc,QAA0B;CAClE,OAAO,KAAK,IAAI,GAAG,MAAM,SAAS,KAAK,OAAO,QAAQ,MAAM,MAAM,MAAM,CAAC,CAAC,KAAK,WAAW,EAAE;AAC7F;;AAGA,SAAS,QAAQ,OAAc,QAA2B;CACzD,MAAM,MAAM,MAAM,OAAO,MAAM;CAC/B,OAAO,CAAC,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,IAAI,YAAY,MAAM,WAAW;AACzE;;;;;;;;AASA,SAAgB,UAAU,OAAc,QAAwB;CAC/D,IAAI,CAAC,QAAQ,OAAO,MAAM,GAAG;CAC7B,MAAM,QAAsC;EAAE;EAAQ,WAAW;CAAM;CACvE,IAAI,MAAM,MAAM,IAAI,iBAAiB,GAAG,MAAM,MAAM,IAAI,mBAAmB,KAAK;CAChF,IAAI,MAAM,WAAW,OAAO,MAAM,QAAQ,QAAQ,MAAM,UAAU,cAAc,cAAc,CAAC;CAC/F,MAAM,MAAM,MAAM,OAAO,MAAM;CAE/B,IAAI,cAAc;CAClB,MAAM,OAAO,KAAK,mBAAmB,EAAE,OAAO,CAAC;CAC/C,OAAO,OAAO,MAAM;CACpB,KAAK,MAAM,SAAS,MAAM,QAAQ,OAAO,GACxC,IAAI,MAAM,OAAO,UAAU,CAAC,MAAM,SAAS,MAAM,QAAQ,MAAM,IAAI,cAAc,eAAe,EAAE,QAAQ,IAAI,KAAK,CAAC,GAAG,MAAM;AAE/H;;;;;;;;AASA,SAAgB,SAAS,OAAc,QAAwB;CAC9D,IAAI,CAAC,QAAQ,OAAO,MAAM,GAAG;CAC7B,MAAM,OAAO,WAAW,OAAO,MAAM;CACrC,IAAI,QAAQ,GAAG,OAAO,MAAM,QAAQ,QAAQ,cAAc,cAAc,CAAC;CACzE,MAAM,QAAkC;EAAE;EAAQ;EAAM,SAAS,MAAM,SAAS,KAAK,OAAO;EAAS,WAAW;CAAM;CACtH,IAAI,MAAM,MAAM,IAAI,aAAa,GAAG,MAAM,MAAM,IAAI,eAAe,KAAK;CACxE,IAAI,MAAM,WAAW,OAAO,MAAM,QAAQ,QAAQ,MAAM,UAAU,cAAc,cAAc,CAAC;CAC/F,MAAM,EAAE,SAAS,MAAM,MAAM,MAAM;CACnC,MAAM,SAAS,QAAQ,EAAE,MAAM;EAAE,GAAG;GAAO,UAAU,KAAK,WAAW,KAAK;CAAE,EAAE,CAAC;CAC/E,MAAM,OAAO,KAAKA,YAAiB;EAAE;EAAQ,SAAS,KAAK,IAAI,GAAG,MAAM,OAAO;EAAG,MAAM,OAAO;CAAE,CAAC;AACnG"}

package/dist/engagement.d.ts

@@ -1,5 +1,5 @@
-import type { Entity } from './entity';
-import type { Vec2 } from './math';
+import { type Entity } from './entity';
+import { type Vec2 } from './math';
 import type { World } from './world';
 /**
  * Where an attacker fights from: `ground`, `air` and `water` for the engine, any other name for a game's own
@@ -7,6 +7,13 @@ import type { World } from './world';
  * @beta
  */
 export type EngageLayer = 'ground' | 'air' | 'water' | (string & {});
+/**
+ * How much farther an attack reaches a structure, whose edge is its footprint's: the navmesh keeps units a little away
+ * from walls (`engage`, the stances pack, and where an attacker stands by a building)
+ *
+ * @beta
+ */
+export declare const STRUCTURE_REACH = 0.4;
 /**
  * Seconds a target that could not be got at is left alone (see `shun`)
  *
@@ -20,7 +27,7 @@ export declare const SHUN_TIME = 4;
  */
 export declare function bandOf(world: World, attacker: Entity): number;
 /**
- * The layer an attacker fights from, as the game's rules say (`GameRules.combat.engageLayer`)
+ * The layer an attacker fights from, as the game's rules say (`RuleSettings.combat.engageLayer`)
  *
  * @beta
  */
@@ -39,7 +46,7 @@ export declare function defaultEngageLayer(_world: World, attacker: Entity): Eng
  */
 export declare function defaultEngageRoom(world: World, target: Entity, attacker: Entity): number;
 /**
- * How many attackers like this one may fight the target at once, as the game's rules say (`GameRules.combat.engageRoom`)
+ * How many attackers like this one may fight the target at once, as the game's rules say (`RuleSettings.combat.engageRoom`)
  *
  * @beta
  */
@@ -76,7 +83,8 @@ export declare function engagedWith(world: World, attacker: Entity): Entity | un
  */
 export declare function engageWith(world: World, attacker: Entity, target: Entity): void;
 /**
- * Lets go of whatever the attacker was engaged with, and of its spot there
+ * Lets go of whatever the attacker was engaged with, and of its spot there. Without the world, the rest of the tick
+ * still counts it there, with its spot
  *
  * @beta
  */
@@ -89,7 +97,7 @@ export declare function release(attacker: Entity, world?: World): void;
  */
 export declare function spotFor(world: World, attacker: Entity, target: Entity): Vec2;
 /**
- * Whether the attacker has been closing in on the target for longer than the game lets it (`GameRules.combat.giveUpChase`) without getting closer
+ * Whether the attacker has been closing in on the target for longer than the game lets it (`RuleSettings.combat.giveUpChase`) without getting closer
  *
  * @beta
  */
@@ -106,3 +114,29 @@ export declare function shun(world: World, attacker: Entity, target: Entity, sec
  * @beta
  */
 export declare function isShunned(world: World, attacker: Entity, target: Entity): boolean;
+/**
+ * The engine's distance from the middle of a target at which an attacker waits for room there
+ * (`RuleSettings.combat.queueDistance`): just behind those fighting it, the target's size, two of the attacker, its reach
+ * and half a cell out
+ *
+ * @beta
+ */
+export declare function defaultQueueDistance(world: World, attacker: Entity, target: Entity): number;
+/**
+ * Where an attacker waits for room at a target (`holdOff`): out at the game's queue distance
+ * (`RuleSettings.combat.queueDistance`) on its own side of it, or at `angle` (seen from the target, about the up axis), on
+ * ground it can stand on
+ *
+ * @beta
+ */
+export declare function queuePoint(world: World, attacker: Entity, target: Entity, angle?: number): Vec2;
+/**
+ * Where the attacker could fight the target from now: a place with room for it (`isCrowded`) where no one stands, nor
+ * is on the way to: round a unit on its ring, round a building by its sides, the nearest its own side first. `straight`
+ * (the default): only one it can walk straight to without pushing through those fighting a unit (round a building, the
+ * way round is the navigation's); false: any, however far round. None when there is no room for it or every place is
+ * taken; the target's own place for what flies. What an attacker waiting for room (`holdOff`) asks before it goes in
+ *
+ * @beta
+ */
+export declare function freeSpot(world: World, attacker: Entity, target: Entity, straight?: boolean): Vec2 | undefined;