@v12-engine/engine 0.1.1 → 0.4.0

package/dist/orders/waiting.d.ts

@@ -0,0 +1,39 @@
+import { type Entity, type EntityId, type Order } from '#engine/entity';
+import type { Vec2 } from '#engine/math';
+import type { World } from '#engine/world';
+/**
+ * What an order that waits for room at its target keeps (`holdOff`): `attack`'s, and a game's own
+ *
+ * @beta
+ */
+export interface WaitState {
+    /** Waiting by its target for room there, out of the way of those fighting it */
+    waiting?: boolean;
+    /** What it hits while it waits, 0 for nothing: the target it was told to attack is still its order's */
+    meanwhile?: EntityId;
+    /** Where it goes in to by a building, once a place there is free */
+    spot?: Vec2;
+    /** The time it gives itself to get there, from the world's start (`World.time`): past it, it waits again */
+    until?: number;
+    /** Whether it has looked, once, for anchored allies between it and its place at the target */
+    looked?: boolean;
+}
+/**
+ * Has the attacker let go of the target and wait for room by it (`queuePoint`): no spot held there, no swing, walking
+ * out of the way of those fighting it to stand. What `holdOff` does when there is no room or no way; a game's own
+ * order may call it as it likes
+ *
+ * @beta
+ */
+export declare function waitBy(world: World, entity: Entity, order: Order<WaitState>, target: Entity): void;
+/**
+ * One tick of an attacker that may have to wait for room at the target it was told to fight, called before `engage`.
+ * Closing in on a target with no room left for one like it (`isCrowded`), or held up on the way past the game's
+ * patience (`isBlocked`), it waits (`waitBy`): just behind those fighting it, on its own side, making way for others,
+ * hitting what else comes into its reach without letting go of its target. Every fourth tick it asks for a free place
+ * by the target (`freeSpot`) and, given one, goes in again. True while it holds off: the caller does not engage this
+ * tick; false when it is to fight as ever
+ *
+ * @beta
+ */
+export declare function holdOff(world: World, entity: Entity, order: Order<WaitState>, target: Entity, dt: number): boolean;

package/dist/orders/waiting.js

@@ -0,0 +1,149 @@
+import { atan2, hypot } from "../exactMath.js";
+import { edgeDistance, fighting, moving } from "../entity.js";
+import { rangeAgainst } from "../attacks.js";
+import { STRUCTURE_REACH, anchoredInWay, engageWith, freeSpot, isBlocked, isCrowded, queuePoint, release, ringSpot, takeSpot } from "../engagement.js";
+import { halt, moveTo, setAnchored } from "../systems/movement.js";
+import { acquireInRange, cancelSwing, engage } from "../systems/combat.js";
+//#region src/orders/waiting.ts
+/** How often, in ticks, a waiting attacker looks for a place by its target and for something in reach */
+var LOOK_EVERY = 4;
+/** Whether the attacker is still on its way to the target: not in reach of it, nor swinging at it */
+function closingIn(world, entity, target) {
+	const combat = entity.get(fighting);
+	if (combat && combat.swing > 0 && combat.swingTarget === target.id) return false;
+	return edgeDistance(entity, target) > rangeAgainst(world, entity, target) + (target.isStructure ? STRUCTURE_REACH : 0);
+}
+/**
+* Has the attacker let go of the target and wait for room by it (`queuePoint`): no spot held there, no swing, walking
+* out of the way of those fighting it to stand. What `holdOff` does when there is no room or no way; a game's own
+* order may call it as it likes
+*
+* @beta
+*/
+function waitBy(world, entity, order, target) {
+	const { state } = order;
+	state.waiting = true;
+	state.spot = void 0;
+	state.until = void 0;
+	state.meanwhile = 0;
+	cancelSwing(world, entity);
+	release(entity, world);
+	if (!entity.get(moving)) return;
+	setAnchored(world, entity, false);
+	const point = roundPoint(world, entity, target) ?? queuePoint(world, entity, target);
+	if (hypot(point.x - entity.pos.x, point.z - entity.pos.z) > .5) moveTo(world, entity, point);
+	else halt(world, entity);
+}
+/**
+* Goes in to the free place by the target: to its spot around a unit, by `engage`; to the place by a building, walked
+* to. True while it walks there
+*/
+function goIn(world, entity, order, target, spot) {
+	const { state } = order;
+	state.waiting = false;
+	if (state.meanwhile) {
+		cancelSwing(world, entity);
+		state.meanwhile = 0;
+	}
+	release(entity, world);
+	engageWith(world, entity, target);
+	if (entity.flying) return false;
+	if (target.def.footprint && closingIn(world, entity, target)) {
+		state.spot = {
+			x: spot.x,
+			z: spot.z
+		};
+		const speed = Math.max(entity.get(moving)?.speed ?? 0, .5);
+		const away = hypot(spot.x - entity.pos.x, spot.z - entity.pos.z);
+		state.until = world.time + away * 2 / speed + world.settings.combat.giveUpChase(world, entity, target);
+		moveTo(world, entity, state.spot);
+		return true;
+	}
+	takeSpot(world, entity, target, atan2(spot.x - target.pos.x, spot.z - target.pos.z) + 0);
+	return false;
+}
+/** Hits what else is in its reach while it waits, as long as it can: what has room for it, its order's target aside */
+function hitMeanwhile(world, entity, order, target, dt) {
+	const { state } = order;
+	const other = state.meanwhile ? world.get(state.meanwhile) : void 0;
+	if (other) {
+		if (engage(world, entity, other, dt, false) === "attacking") return;
+		state.meanwhile = 0;
+		setAnchored(world, entity, false);
+	}
+	if ((world.tick + entity.id) % LOOK_EVERY !== 0 || !entity.def.attacks?.length) return;
+	const found = acquireInRange(world, entity);
+	if (!found || found === target || isCrowded(world, found, entity)) return;
+	state.meanwhile = found.id;
+	engageWith(world, entity, found);
+}
+/**
+* One tick of an attacker that may have to wait for room at the target it was told to fight, called before `engage`.
+* Closing in on a target with no room left for one like it (`isCrowded`), or held up on the way past the game's
+* patience (`isBlocked`), it waits (`waitBy`): just behind those fighting it, on its own side, making way for others,
+* hitting what else comes into its reach without letting go of its target. Every fourth tick it asks for a free place
+* by the target (`freeSpot`) and, given one, goes in again. True while it holds off: the caller does not engage this
+* tick; false when it is to fight as ever
+*
+* @beta
+*/
+function holdOff(world, entity, order, target, dt) {
+	const m = entity.get(moving);
+	if (!m) return false;
+	const { state } = order;
+	if (state.spot) {
+		if (m.status !== "moving" || !closingIn(world, entity, target)) {
+			state.spot = void 0;
+			state.until = void 0;
+			return false;
+		}
+		if (world.time > (state.until ?? 0)) waitBy(world, entity, order, target);
+		return true;
+	}
+	if (!state.waiting) {
+		if (!closingIn(world, entity, target)) return false;
+		if (!isCrowded(world, target, entity) && !isBlocked(world, entity, target)) {
+			if (state.looked || (world.tick + entity.id) % LOOK_EVERY !== 0) return false;
+			state.looked = true;
+			if (!anchoredInWay(world, entity, target)) return false;
+		}
+		waitBy(world, entity, order, target);
+		return true;
+	}
+	if ((world.tick + entity.id) % LOOK_EVERY === 0) {
+		const spot = closingIn(world, entity, target) ? freeSpot(world, entity, target) : isCrowded(world, target, entity) ? void 0 : entity.pos;
+		if (spot) return goIn(world, entity, order, target, spot);
+		if (!state.meanwhile && (m.status !== "moving" || m.goalEntity === 0 && hypot(m.goal.x - entity.pos.x, m.goal.z - entity.pos.z) < 1)) goRound(world, entity, target);
+	}
+	hitMeanwhile(world, entity, order, target, dt);
+	return true;
+}
+/** The most a waiting attacker goes round its target at a time, as an angle: a waypoint every 45 degrees, outside those fighting it */
+var ROUND_STEP = Math.PI / 4;
+/**
+* The next waypoint for a waiting attacker, round a unit towards the nearest free place by angle that it can go in to
+* from outside those fighting it (`ringSpot`): at queue distance, at most 45 degrees round from where it is. After a
+* target that walked off, where it waits now. None when there is no place, or it is at the angle of it already (it goes
+* in from there once its way is clear), or for a building (the way round is the navigation's)
+*/
+function roundPoint(world, entity, target) {
+	if (target.isStructure) return void 0;
+	if (hypot(entity.pos.x - target.pos.x, entity.pos.z - target.pos.z) > world.settings.combat.queueDistance(world, entity, target) + 2) return queuePoint(world, entity, target);
+	const spot = ringSpot(world, entity, target);
+	if (!spot) return void 0;
+	const from = atan2(entity.pos.x - target.pos.x, entity.pos.z - target.pos.z);
+	let turn = atan2(spot.x - target.pos.x, spot.z - target.pos.z) - from;
+	if (turn > Math.PI) turn -= Math.PI * 2;
+	else if (turn < -Math.PI) turn += Math.PI * 2;
+	if (Math.abs(turn) < .05) return void 0;
+	return queuePoint(world, entity, target, from + Math.min(Math.max(turn, -ROUND_STEP), ROUND_STEP));
+}
+/** Has a waiting attacker that stands still, or is all but at its waypoint, walk on round the ring (`roundPoint`) */
+function goRound(world, entity, target) {
+	const point = roundPoint(world, entity, target);
+	if (point && hypot(point.x - entity.pos.x, point.z - entity.pos.z) > .5) moveTo(world, entity, point);
+}
+//#endregion
+export { holdOff, waitBy };
+
+//# sourceMappingURL=waiting.js.map

package/dist/orders/waiting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waiting.js","names":[],"sources":["../../src/orders/waiting.ts"],"sourcesContent":["/*\n * Waiting for room at a fight: an attacker that closes in on a target with no room left for it, or no way to it through\n * its own, does not push into the backs of those fighting it. It stands just behind them on its own side, out of the\n * way (it makes way for others: `OrderBehavior.waiting`), hits what else comes into its reach, and goes in again as a\n * place by the target frees up. `attack` waits so; a game's own order that fights can too\n */\nimport { edgeDistance, type Entity, type EntityId, fighting, moving, type Order } from '#engine/entity'\nimport type { Vec2 } from '#engine/math'\nimport type { World } from '#engine/world'\nimport { acquireInRange, cancelSwing, engage, STRUCTURE_REACH } from '#engine/systems/combat'\nimport { halt, moveTo, setAnchored } from '#engine/systems/movement'\nimport { anchoredInWay, engageWith, freeSpot, isBlocked, isCrowded, queuePoint, release, ringSpot, takeSpot } from '#engine/engagement'\nimport { rangeAgainst } from '#engine/attacks'\nimport { atan2, hypot } from '#engine/exactMath'\n\n/**\n * What an order that waits for room at its target keeps (`holdOff`): `attack`'s, and a game's own\n *\n * @beta\n */\nexport interface WaitState {\n\t/** Waiting by its target for room there, out of the way of those fighting it */\n\twaiting?: boolean\n\t/** What it hits while it waits, 0 for nothing: the target it was told to attack is still its order's */\n\tmeanwhile?: EntityId\n\t/** Where it goes in to by a building, once a place there is free */\n\tspot?: Vec2\n\t/** The time it gives itself to get there, from the world's start (`World.time`): past it, it waits again */\n\tuntil?: number\n\t/** Whether it has looked, once, for anchored allies between it and its place at the target */\n\tlooked?: boolean\n}\n\n/** How often, in ticks, a waiting attacker looks for a place by its target and for something in reach */\nconst LOOK_EVERY = 4\n\n/** Whether the attacker is still on its way to the target: not in reach of it, nor swinging at it */\nfunction closingIn(world: World, entity: Entity, target: Entity): boolean {\n\tconst combat = entity.get(fighting)\n\tif (combat && combat.swing > 0 && combat.swingTarget === target.id) return false\n\treturn edgeDistance(entity, target) > rangeAgainst(world, entity, target) + (target.isStructure ? STRUCTURE_REACH : 0)\n}\n\n/**\n * Has the attacker let go of the target and wait for room by it (`queuePoint`): no spot held there, no swing, walking\n * out of the way of those fighting it to stand. What `holdOff` does when there is no room or no way; a game's own\n * order may call it as it likes\n *\n * @beta\n */\nexport function waitBy(world: World, entity: Entity, order: Order<WaitState>, target: Entity): void {\n\tconst { state } = order\n\tstate.waiting = true\n\tstate.spot = undefined\n\tstate.until = undefined\n\tstate.meanwhile = 0\n\tcancelSwing(world, entity)\n\trelease(entity, world)\n\tconst m = entity.get(moving)\n\tif (!m) return\n\tsetAnchored(world, entity, false)\n\t// round the ring towards a place it can go in to, or just behind those fighting on its own side\n\tconst point = roundPoint(world, entity, target) ?? queuePoint(world, entity, target)\n\tif (hypot(point.x - entity.pos.x, point.z - entity.pos.z) > 0.5) moveTo(world, entity, point)\n\telse halt(world, entity)\n}\n\n/**\n * Goes in to the free place by the target: to its spot around a unit, by `engage`; to the place by a building, walked\n * to. True while it walks there\n */\nfunction goIn(world: World, entity: Entity, order: Order<WaitState>, target: Entity, spot: Vec2): boolean {\n\tconst { state } = order\n\tstate.waiting = false\n\tif (state.meanwhile) {\n\t\tcancelSwing(world, entity)\n\t\tstate.meanwhile = 0\n\t}\n\trelease(entity, world)\n\tengageWith(world, entity, target)\n\tif (entity.flying) return false\n\tif (target.def.footprint && closingIn(world, entity, target)) {\n\t\tstate.spot = { x: spot.x, z: spot.z }\n\t\t// as long as the walk would take at half its speed, and the game's patience with a chase that stalls\n\t\tconst speed = Math.max(entity.get(moving)?.speed ?? 0, 0.5)\n\t\tconst away = hypot(spot.x - entity.pos.x, spot.z - entity.pos.z)\n\t\tstate.until = world.time + (away * 2) / speed + world.settings.combat.giveUpChase(world, entity, target)\n\t\tmoveTo(world, entity, state.spot)\n\t\treturn true\n\t}\n\t// its spot there is the free one it found ('+ 0': no -0, which a save writes as 0)\n\ttakeSpot(world, entity, target, atan2(spot.x - target.pos.x, spot.z - target.pos.z) + 0)\n\treturn false\n}\n\n/** Hits what else is in its reach while it waits, as long as it can: what has room for it, its order's target aside */\nfunction hitMeanwhile(world: World, entity: Entity, order: Order<WaitState>, target: Entity, dt: number): void {\n\tconst { state } = order\n\tconst other = state.meanwhile ? world.get(state.meanwhile) : undefined\n\tif (other) {\n\t\tif (engage(world, entity, other, dt, false) === 'attacking') return\n\t\t// out of reach, or gone: let be, and free to be asked aside again\n\t\tstate.meanwhile = 0\n\t\tsetAnchored(world, entity, false)\n\t}\n\tif ((world.tick + entity.id) % LOOK_EVERY !== 0 || !entity.def.attacks?.length) return\n\tconst found = acquireInRange(world, entity)\n\tif (!found || found === target || isCrowded(world, found, entity)) return\n\tstate.meanwhile = found.id\n\t// claimed at once, so that others picking in the same tick count it\n\tengageWith(world, entity, found)\n}\n\n/**\n * One tick of an attacker that may have to wait for room at the target it was told to fight, called before `engage`.\n * Closing in on a target with no room left for one like it (`isCrowded`), or held up on the way past the game's\n * patience (`isBlocked`), it waits (`waitBy`): just behind those fighting it, on its own side, making way for others,\n * hitting what else comes into its reach without letting go of its target. Every fourth tick it asks for a free place\n * by the target (`freeSpot`) and, given one, goes in again. True while it holds off: the caller does not engage this\n * tick; false when it is to fight as ever\n *\n * @beta\n */\nexport function holdOff(world: World, entity: Entity, order: Order<WaitState>, target: Entity, dt: number): boolean {\n\tconst m = entity.get(moving)\n\t// what does not walk does not wait: it fights from where it is or not at all\n\tif (!m) return false\n\tconst { state } = order\n\tif (state.spot) {\n\t\t// on its way in to a free place by a building: there, in reach, or stopped, it fights as ever\n\t\tif (m.status !== 'moving' || !closingIn(world, entity, target)) {\n\t\t\tstate.spot = undefined\n\t\t\tstate.until = undefined\n\t\t\treturn false\n\t\t}\n\t\t// held up on the way, past the time it gave itself: back to wait\n\t\tif (world.time > (state.until ?? 0)) waitBy(world, entity, order, target)\n\t\treturn true\n\t}\n\tif (!state.waiting) {\n\t\tif (!closingIn(world, entity, target)) return false\n\t\tif (!isCrowded(world, target, entity) && !isBlocked(world, entity, target)) {\n\t\t\t// its side of the target held by those anchored in the fight: once, it trades its place for one it can get to\n\t\t\tif (state.looked || (world.tick + entity.id) % LOOK_EVERY !== 0) return false\n\t\t\tstate.looked = true\n\t\t\tif (!anchoredInWay(world, entity, target)) return false\n\t\t}\n\t\twaitBy(world, entity, order, target)\n\t\treturn true\n\t}\n\tif ((world.tick + entity.id) % LOOK_EVERY === 0) {\n\t\t// in reach where it stands, with room for it: in it goes from there\n\t\tconst spot = closingIn(world, entity, target) ? freeSpot(world, entity, target) : isCrowded(world, target, entity) ? undefined : entity.pos\n\t\tif (spot) return goIn(world, entity, order, target, spot)\n\t\t// standing, or all but at the waypoint it walks to: on to the next\n\t\tif (!state.meanwhile && (m.status !== 'moving' || (m.goalEntity === 0 && hypot(m.goal.x - entity.pos.x, m.goal.z - entity.pos.z) < 1)))\n\t\t\tgoRound(world, entity, target)\n\t}\n\thitMeanwhile(world, entity, order, target, dt)\n\treturn true\n}\n\n/** The most a waiting attacker goes round its target at a time, as an angle: a waypoint every 45 degrees, outside those fighting it */\nconst ROUND_STEP = Math.PI / 4\n\n/**\n * The next waypoint for a waiting attacker, round a unit towards the nearest free place by angle that it can go in to\n * from outside those fighting it (`ringSpot`): at queue distance, at most 45 degrees round from where it is. After a\n * target that walked off, where it waits now. None when there is no place, or it is at the angle of it already (it goes\n * in from there once its way is clear), or for a building (the way round is the navigation's)\n */\nfunction roundPoint(world: World, entity: Entity, target: Entity): Vec2 | undefined {\n\tif (target.isStructure) return undefined\n\tconst away = hypot(entity.pos.x - target.pos.x, entity.pos.z - target.pos.z)\n\tif (away > world.settings.combat.queueDistance(world, entity, target) + 2) return queuePoint(world, entity, target)\n\tconst spot = ringSpot(world, entity, target)\n\tif (!spot) return undefined\n\tconst from = atan2(entity.pos.x - target.pos.x, entity.pos.z - target.pos.z)\n\tlet turn = atan2(spot.x - target.pos.x, spot.z - target.pos.z) - from\n\tif (turn > Math.PI) turn -= Math.PI * 2\n\telse if (turn < -Math.PI) turn += Math.PI * 2\n\tif (Math.abs(turn) < 0.05) return undefined\n\treturn queuePoint(world, entity, target, from + Math.min(Math.max(turn, -ROUND_STEP), ROUND_STEP))\n}\n\n/** Has a waiting attacker that stands still, or is all but at its waypoint, walk on round the ring (`roundPoint`) */\nfunction goRound(world: World, entity: Entity, target: Entity): void {\n\tconst point = roundPoint(world, entity, target)\n\tif (point && hypot(point.x - entity.pos.x, point.z - entity.pos.z) > 0.5) moveTo(world, entity, point)\n}\n"],"mappings":"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"}