@v12-engine/engine 0.1.0 → 0.4.0

package/dist/engagement.js

@@ -0,0 +1,530 @@
+import { atan2, cos, hypot, sin } from "./exactMath.js";
+import { closestPointOnRect } from "./math.js";
+import { statsOf } from "./stats.js";
+import { distanceToEdge, fighting, moving } from "./entity.js";
+import { rangeAgainst } from "./attacks.js";
+//#region src/engagement.ts
+/** How wide one ring of reach is: attackers whose ranges are this close fight from the same ring */
+var BAND = 1.5;
+/**
+* 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
+*/
+var STRUCTURE_REACH = .4;
+/** Spots on a ring at most: past that, room is there for everyone */
+var MOST_SLOTS = 48;
+/**
+* Seconds a target that could not be got at is left alone (see `shun`)
+*
+* @beta
+*/
+var SHUN_TIME = 4;
+/**
+* The ring an attacker fights from, by its reach: 0 for the melee
+*
+* @beta
+*/
+function bandOf(world, attacker) {
+	return Math.floor(statsOf(world, attacker).attackRange / BAND);
+}
+/**
+* The layer an attacker fights from, as the game's rules say (`RuleSettings.combat.engageLayer`)
+*
+* @beta
+*/
+function engageLayer(world, attacker) {
+	return world.settings.combat.engageLayer(world, attacker);
+}
+/**
+* The engine's: from the air for what flies, from the water for boats, from the ground for the rest
+*
+* @beta
+*/
+function defaultEngageLayer(_world, attacker) {
+	return attacker.flying ? "air" : attacker.def.naval ? "water" : "ground";
+}
+/**
+* The engine's room around a target for attackers like this one: as many as stand side by side around it, on the ring
+* they fight from. Few for the melee around a footman, many around a town hall, all of them for long guns
+*
+* @beta
+*/
+function defaultEngageRoom(world, target, attacker) {
+	const reach = rangeAgainst(world, attacker, target);
+	const width = attacker.def.radius * 2 + .15;
+	const footprint = target.def.footprint;
+	const edge = footprint ? 2 * (footprint.w + footprint.d) : 2 * Math.PI * target.def.radius;
+	return Math.max(1, Math.floor((edge + 2 * Math.PI * (attacker.def.radius + reach)) / width));
+}
+/**
+* How many attackers like this one may fight the target at once, as the game's rules say (`RuleSettings.combat.engageRoom`)
+*
+* @beta
+*/
+function roomFor(world, target, attacker) {
+	return world.settings.combat.engageRoom(world, target, attacker);
+}
+/** Who is engaged with whom, worked out again once a tick, when first asked */
+var index = /* @__PURE__ */ new WeakMap();
+function engagements(world) {
+	let cached = index.get(world);
+	if (cached?.tick === world.tick) return cached.by;
+	if (!cached) index.set(world, cached = {
+		tick: world.tick,
+		by: /* @__PURE__ */ new Map()
+	});
+	cached.tick = world.tick;
+	cached.by.clear();
+	for (const entity of world.units.values()) {
+		const target = entity.get(fighting)?.engaged;
+		if (!target || !entity.alive) continue;
+		const engaged = cached.by.get(target);
+		if (engaged) engaged.all.push(entity);
+		else cached.by.set(target, {
+			all: [entity],
+			rings: void 0
+		});
+	}
+	return cached.by;
+}
+/** Puts the attacker on the list of what it is engaged with now, in this tick's index: others picking in the same tick see it at once */
+function enlist(world, attacker, target) {
+	const by = engagements(world);
+	const engaged = by.get(target.id);
+	if (!engaged) by.set(target.id, {
+		all: [attacker],
+		rings: void 0
+	});
+	else {
+		engaged.all.push(attacker);
+		if (engaged.rings) join(engaged.rings, attacker, engageLayer(world, attacker), bandOf(world, attacker));
+		moved(world, target.id);
+	}
+}
+/** Takes the attacker off the list of what it was engaged with, in this tick's index */
+function unlist(world, attacker) {
+	const id = attacker.get(fighting)?.engaged;
+	const cached = index.get(world);
+	if (!id || cached?.tick !== world.tick) return;
+	const engaged = cached.by.get(id);
+	if (!engaged || !drop(engaged.all, attacker) || !engaged.rings) return;
+	for (const ring of engaged.rings) if (drop(ring.members, attacker)) break;
+	moved(world, id);
+}
+/** Takes the first of the attacker off the list: whether it was on it */
+function drop(list, attacker) {
+	const at = list.indexOf(attacker);
+	if (at >= 0) list.splice(at, 1);
+	return at >= 0;
+}
+/** Adds the attacker to its ring of those round a target, making the ring when it is the first of it */
+function join(rings, attacker, layer, band) {
+	for (const ring of rings) {
+		if (ring.layer !== layer || ring.band !== band) continue;
+		ring.members.push(attacker);
+		return;
+	}
+	rings.push({
+		layer,
+		band,
+		members: [attacker],
+		held: /* @__PURE__ */ new Map()
+	});
+}
+/** Forgets the spots held round a target as this tick's index has them: one engaged with it took or let go of one */
+function moved(world, target) {
+	const cached = index.get(world);
+	if (cached?.tick !== world.tick) return;
+	for (const ring of cached.by.get(target)?.rings ?? []) ring.held.clear();
+}
+/** The ring of those engaged with the target of an attacker of that layer and band, the attacker in it if it is one */
+function ringOf(world, target, layer, band) {
+	const engaged = engagements(world).get(target.id);
+	if (!engaged) return void 0;
+	if (!engaged.rings) {
+		engaged.rings = [];
+		for (const other of engaged.all) join(engaged.rings, other, engageLayer(world, other), bandOf(world, other));
+	}
+	for (const ring of engaged.rings) if (ring.layer === layer && ring.band === band) return ring;
+}
+/**
+* Everyone fighting the target or closing in on it: of one layer only, when one is named
+*
+* @beta
+*/
+function attackersOf(world, target, layer) {
+	const all = engagements(world).get(target.id)?.all ?? [];
+	return layer === void 0 ? [...all] : all.filter((attacker) => engageLayer(world, attacker) === layer);
+}
+/**
+* How many attackers like this one (the same layer, the same ring) the target has already, the attacker left out
+*
+* @beta
+*/
+function engagedLike(world, target, attacker) {
+	const ring = ringOf(world, target, engageLayer(world, attacker), bandOf(world, attacker));
+	let count = 0;
+	if (ring) {
+		for (const other of ring.members) if (other !== attacker) count++;
+	}
+	return count;
+}
+/**
+* Whether the target has no room left for another attacker like this one
+*
+* @beta
+*/
+function isCrowded(world, target, attacker) {
+	return engagedLike(world, target, attacker) >= roomFor(world, target, attacker);
+}
+/**
+* What the attacker is fighting or closing in on, if anything
+*
+* @beta
+*/
+function engagedWith(world, attacker) {
+	const id = attacker.get(fighting)?.engaged;
+	return id ? world.get(id) : void 0;
+}
+/**
+* Marks the attacker engaged with the target, giving it a spot around it when it fights from close by (and has none
+* there yet). The engine does this as a unit fights or closes in; a game's own fighting can too
+*
+* @beta
+*/
+function engageWith(world, attacker, target) {
+	const combat = attacker.get(fighting);
+	if (!combat) return;
+	if (combat.engaged === target.id && combat.slot !== null) return;
+	if (combat.engaged !== target.id) {
+		unlist(world, attacker);
+		enlist(world, attacker, target);
+	}
+	const had = combat.slot;
+	combat.engaged = target.id;
+	combat.slot = null;
+	if (!attacker.flying && !target.def.footprint) combat.slot = chooseSlot(world, attacker, target);
+	if (combat.slot !== had) moved(world, target.id);
+}
+/**
+* Gives the attacker engaged with the target the spot round it at that angle, seen from it: where one that waited for
+* room goes in to (`holdOff`)
+*
+* @internal
+*/
+function takeSpot(world, attacker, target, angle) {
+	const combat = attacker.get(fighting);
+	if (!combat) return;
+	combat.slot = angle;
+	moved(world, target.id);
+}
+/**
+* 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
+*/
+function release(attacker, world) {
+	const combat = attacker.get(fighting);
+	if (!combat) return;
+	if (world && combat.engaged) unlist(world, attacker);
+	combat.engaged = 0;
+	combat.slot = null;
+}
+/** The spots others hold on the ring of an attacker that holds one there too: filled again for each such ask */
+var others = /* @__PURE__ */ new Set();
+var nowhere = /* @__PURE__ */ new Set();
+/**
+* The spots of the attacker's ring around the target that others like it hold, by number: `count` of them round it, the
+* first straight down the z axis from the target
+*
+* @internal
+*/
+function heldSlots(world, attacker, target, count) {
+	const ring = ringOf(world, target, engageLayer(world, attacker), bandOf(world, attacker));
+	if (!ring) return nowhere;
+	const own = attacker.get(fighting)?.slot;
+	if (own !== null && own !== void 0) return spotsHeld(ring.members, attacker, count, others);
+	let held = ring.held.get(count);
+	if (!held) ring.held.set(count, held = spotsHeld(ring.members, attacker, count, /* @__PURE__ */ new Set()));
+	return held;
+}
+/** The spots, of `count` round a target, that those on a ring hold, the attacker left out: into `into`, emptied first */
+function spotsHeld(members, attacker, count, into) {
+	const step = Math.PI * 2 / count;
+	into.clear();
+	for (const other of members) {
+		const slot = other.get(fighting)?.slot;
+		if (other === attacker || slot === null || slot === void 0) continue;
+		into.add((Math.round(slot / step) % count + count) % count);
+	}
+	return into;
+}
+/** The direction the attacker is in, seen from the target: an angle about the up axis */
+function angleFrom(attacker, target) {
+	return atan2(attacker.pos.x - target.pos.x, attacker.pos.z - target.pos.z) + 0;
+}
+/**
+* The k-th spot by number out from the nearest, one side and then the other: the nearest, the one past it, the one
+* before it, two past it, and so on (the nearest as it is: a -0 stays one, as an angle of it did)
+*/
+var outFrom = (nearest, k) => k % 2 ? nearest + (k + 1) / 2 : nearest - k / 2;
+/**
+* A free spot around the target for the attacker, as an angle seen from the target: the one nearest the side it comes
+* from, of those on its ring that no one like it holds. None when every one is held: never one held already
+*/
+function chooseSlot(world, attacker, target) {
+	const from = angleFrom(attacker, target);
+	const count = Math.min(roomFor(world, target, attacker), MOST_SLOTS);
+	const held = heldSlots(world, attacker, target, Math.max(count, 1));
+	if (count <= 1) return held.size ? null : from;
+	const step = Math.PI * 2 / count;
+	const nearest = Math.round(from / step);
+	for (let k = 0; k <= 2 * Math.floor(count / 2); k++) {
+		const at = outFrom(nearest, k);
+		if (!held.has((at % count + count) % count)) return at * step + 0;
+	}
+	return null;
+}
+/**
+* Where the attacker goes to fight the target from: its spot around it, out where its weapon reaches, or the target
+* itself without one. The game's `approach` hook has the last word
+*
+* @beta
+*/
+function spotFor(world, attacker, target) {
+	const slot = attacker.get(fighting)?.engaged === target.id ? attacker.get(fighting).slot : null;
+	let point = target.pos;
+	if (slot !== null && slot !== void 0) {
+		const reach = rangeAgainst(world, attacker, target);
+		const out = Math.max(target.def.radius + attacker.def.radius + reach * .5 - .5, target.def.radius * .5);
+		point = {
+			x: target.pos.x + sin(slot) * out,
+			z: target.pos.z + cos(slot) * out
+		};
+	}
+	if (!world.hooks.has("approach")) return point;
+	return world.hooks.run("approach", {
+		attacker,
+		target,
+		point
+	}).point;
+}
+/**
+* Whether the attacker has been closing in on the target for longer than the game lets it (`RuleSettings.combat.giveUpChase`) without getting closer
+*
+* @beta
+*/
+function isBlocked(world, attacker, target) {
+	const m = attacker.get(moving);
+	if (!m || m.goalEntity !== target.id) return false;
+	return (m.status === "failed" ? Infinity : m.status === "moving" ? m.stalledTime : 0) > world.settings.combat.giveUpChase(world, attacker, target);
+}
+/**
+* Has the attacker leave the target alone for a while: not picked by itself again until then
+*
+* @beta
+*/
+function shun(world, attacker, target, seconds = 4) {
+	const combat = attacker.get(fighting);
+	if (!combat) return;
+	const until = world.time + seconds;
+	combat.shunned = (combat.shunned ?? []).filter(([id, end]) => id !== target.id && end > world.time);
+	combat.shunned.push([target.id, until]);
+}
+/**
+* Whether the attacker leaves the target alone for now (see `shun`)
+*
+* @beta
+*/
+function isShunned(world, attacker, target) {
+	const shunned = attacker.get(fighting)?.shunned;
+	if (!shunned?.length) return false;
+	for (let i = 0; i < shunned.length; i++) if (shunned[i][0] === target.id && shunned[i][1] > world.time) return true;
+	return false;
+}
+/**
+* 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
+*/
+function defaultQueueDistance(world, attacker, target) {
+	const footprint = target.def.footprint;
+	return (footprint ? hypot(footprint.w, footprint.d) / 2 : target.def.radius) + 2 * attacker.def.radius + rangeAgainst(world, attacker, target) + .5;
+}
+/**
+* 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
+*/
+function queuePoint(world, attacker, target, angle = angleFrom(attacker, target)) {
+	const out = world.settings.combat.queueDistance(world, attacker, target);
+	const point = {
+		x: target.pos.x + sin(angle) * out,
+		z: target.pos.z + cos(angle) * out
+	};
+	return world.navFor(attacker).closestPoint(point, 2) ?? point;
+}
+/** What stands around a spot, asked of the grid again and again */
+var around = [];
+/**
+* Whether no one stands on the point for the attacker to stand there: no one but itself and its target, nor an ally that
+* would step aside for it (`RuleSettings.movement.makesWay`: standing about, or waiting as it does)
+*/
+function standsFree(world, attacker, target, point) {
+	const radius = attacker.def.radius;
+	for (const other of world.spatial.query(point.x, point.z, radius, around)) {
+		if (other === attacker || other === target || !other.alive || other.hidden || other.flying) continue;
+		if ((other.def.footprint ? distanceToEdge(point, other) : hypot(other.pos.x - point.x, other.pos.z - point.z) - other.def.radius) >= radius * .85) continue;
+		if (!world.areAllies(attacker.owner, other.owner) || !world.settings.movement.makesWay(world, attacker, other)) return false;
+	}
+	return true;
+}
+/**
+* Whether the attacker can walk straight to a point by a unit it fights: not through it, nor through anyone who would not
+* step aside for it on the way. (Round a building, the way round is the navigation's, and a walk held up is given up)
+*/
+function clearWay(world, attacker, target, point, origin = attacker.pos) {
+	if (target.def.footprint) return true;
+	const radius = attacker.def.radius;
+	const dx = point.x - origin.x;
+	const dz = point.z - origin.z;
+	const length = hypot(dx, dz);
+	const steps = Math.ceil(length / .5);
+	for (let i = 1; i <= steps; i++) {
+		const x = origin.x + dx * i / steps;
+		const z = origin.z + dz * i / steps;
+		if (hypot(target.pos.x - x, target.pos.z - z) < target.def.radius + radius - .1) return false;
+		for (const other of world.spatial.query(x, z, radius, around)) {
+			if (other === attacker || other === target || !other.alive || other.hidden || other.flying || other.def.footprint) continue;
+			if (hypot(other.pos.x - x, other.pos.z - z) >= other.def.radius + radius - .1) continue;
+			if (!world.areAllies(attacker.owner, other.owner) || !world.settings.movement.makesWay(world, attacker, other)) return false;
+		}
+	}
+	return true;
+}
+/** The queue point in the direction (x, z), of unit length, from the target */
+function queueAt(world, attacker, target, x, z) {
+	const out = world.settings.combat.queueDistance(world, attacker, target);
+	return {
+		x: target.pos.x + x * out,
+		z: target.pos.z + z * out
+	};
+}
+/**
+* Which way from the target the spots are that others like the attacker are on their way to (`spotFor`'s), as x, z
+* pairs of unit length: filled again by every `findSpot`
+*/
+var heading = [];
+/** Whether a place out at `out` in the direction (x, z) from the target is less than `width` from a spot in `heading` */
+function headedFor(x, z, out, width) {
+	for (let i = 0; i < heading.length; i += 2) if (hypot(heading[i] - x, heading[i + 1] - z) * out < width) return true;
+	return false;
+}
+/** The place `findSpot` tries, made again for each: copied when it is the one */
+var trying = {
+	x: 0,
+	z: 0
+};
+/**
+* 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
+*/
+function freeSpot(world, attacker, target, straight = true) {
+	return findSpot(world, attacker, target, straight ? "straight" : "any");
+}
+/**
+* The nearest place by angle from the attacker's side, of those with room for it, that it can go in to from outside
+* those fighting the target (from the queue point at its angle): where an attacker whose own side is held goes round the
+* ring to (`holdOff`). Whether it can walk straight there from where it stands is not asked
+*
+* @internal
+*/
+function ringSpot(world, attacker, target) {
+	return findSpot(world, attacker, target, "ring");
+}
+/**
+* Whether an ally anchored in a fight stands on the straight way from the attacker to the place it would fight its unit
+* target from (`spotFor`, the `approach` hook's point): what an attacker coming in on a held side finds out before it
+* walks into their backs
+*
+* @internal
+*/
+function anchoredInWay(world, attacker, target) {
+	const slot = attacker.get(fighting)?.slot;
+	if (slot === null || slot === void 0 || target.def.footprint || attacker.flying) return false;
+	const spot = spotFor(world, attacker, target);
+	const dx = spot.x - attacker.pos.x;
+	const dz = spot.z - attacker.pos.z;
+	const length = hypot(dx, dz);
+	if (length > 12) return false;
+	const radius = attacker.def.radius;
+	const steps = Math.ceil(length / .5);
+	for (let i = 1; i <= steps; i++) {
+		const x = attacker.pos.x + dx * i / steps;
+		const z = attacker.pos.z + dz * i / steps;
+		for (const other of world.spatial.query(x, z, radius, around)) {
+			if (other === attacker || other === target || !other.alive || other.hidden || other.flying || other.def.footprint) continue;
+			if (!other.get(moving)?.anchored || !world.areAllies(attacker.owner, other.owner)) continue;
+			if (hypot(other.pos.x - x, other.pos.z - z) < other.def.radius + radius - .1) return true;
+		}
+	}
+	return false;
+}
+function findSpot(world, attacker, target, way) {
+	if (isCrowded(world, target, attacker)) return void 0;
+	if (attacker.flying) return target.pos;
+	const reach = rangeAgainst(world, attacker, target);
+	const footprint = target.def.footprint;
+	const margin = attacker.def.radius + Math.max(reach + (footprint ? STRUCTURE_REACH : 0) - .15, .05);
+	const out = target.def.radius + margin;
+	const width = attacker.def.radius * 2 + .15;
+	const count = Math.max(8, Math.floor((footprint ? 2 * (footprint.w + footprint.d) + 2 * Math.PI * margin : 2 * Math.PI * out) / (width / 4)));
+	const step = Math.PI * 2 / count;
+	heading.length = 0;
+	if (!footprint) for (const other of ringOf(world, target, engageLayer(world, attacker), bandOf(world, attacker))?.members ?? []) {
+		const slot = other.get(fighting)?.slot;
+		if (other === attacker || slot === null || slot === void 0 || other.get(moving)?.status !== "moving") continue;
+		heading.push(sin(slot), cos(slot));
+	}
+	const hooked = world.hooks.has("approach");
+	const nearest = Math.round(angleFrom(attacker, target) / step);
+	for (let k = 0; k <= 2 * Math.floor(count / 2); k++) {
+		const angle = outFrom(nearest, k) * step;
+		const x = sin(angle);
+		const z = cos(angle);
+		if (headedFor(x, z, out, width)) continue;
+		trying.x = target.pos.x + x * out;
+		trying.z = target.pos.z + z * out;
+		let point = footprint ? closestPointOnRect(trying, target.rect, margin) : trying;
+		if (!footprint && hooked) point = world.hooks.run("approach", {
+			attacker,
+			target,
+			point: {
+				x: trying.x,
+				z: trying.z
+			}
+		}).point;
+		if (!standsFree(world, attacker, target, point)) continue;
+		if (way !== "any" && !clearWay(world, attacker, target, point, way === "straight" ? attacker.pos : queueAt(world, attacker, target, x, z))) continue;
+		return point === trying ? {
+			x: trying.x,
+			z: trying.z
+		} : point;
+	}
+}
+//#endregion
+export { SHUN_TIME, STRUCTURE_REACH, anchoredInWay, attackersOf, bandOf, defaultEngageLayer, defaultEngageRoom, defaultQueueDistance, engageLayer, engageWith, engagedLike, engagedWith, freeSpot, heldSlots, isBlocked, isCrowded, isShunned, queuePoint, release, ringSpot, roomFor, shun, spotFor, takeSpot };
+
+//# sourceMappingURL=engagement.js.map

package/dist/engagement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engagement.js","names":[],"sources":["../src/engagement.ts"],"sourcesContent":["import { distanceToEdge, type Entity, type EntityId } from './entity'\nimport { closestPointOnRect, type Vec2 } from './math'\nimport { statsOf } from './stats'\nimport { rangeAgainst } from './attacks'\nimport type { World } from './world'\nimport { atan2, cos, hypot, sin } from './exactMath'\nimport { moving, fighting } from './entity'\n\n/*\n * Who fights whom, and where around them: so that a crowd spreads around what it fights instead of queueing behind\n * the first to get there, picks another enemy when one is full, and does not stand still behind its own.\n *\n * An attacker fighting or closing in on a target is engaged with it (`CombatState.engaged`). Around every target there\n * is room for so many attackers at once (`RuleSettings.combat.engageRoom`), counted apart for each layer they fight from\n * (`RuleSettings.combat.engageLayer`: the ground, the air, the water, or a game's own) and for how far they reach: the melee in\n * one ring, short bows in a wider one, long guns in one wider still. Melee and the like take a spot of their own on\n * their ring (`CombatState.slot`), and walk there, which is what makes them surround it. A unit that picked a target\n * itself and cannot get at it for a while (`RuleSettings.combat.giveUpChase`) lets it go, and leaves it alone for a few seconds.\n *\n * All of it is the engine's way until a game says otherwise: the rules, the `targetScore` hook (which is told how full\n * a target is) and the `approach` hook (where an attacker goes to fight). And all of it can be asked about, from here.\n */\n\n/**\n * Where an attacker fights from: `ground`, `air` and `water` for the engine, any other name for a game's own\n *\n * @beta\n */\nexport type EngageLayer = 'ground' | 'air' | 'water' | (string & {})\n\n/** How wide one ring of reach is: attackers whose ranges are this close fight from the same ring */\nconst BAND = 1.5\n/**\n * How much farther an attack reaches a structure, whose edge is its footprint's: the navmesh keeps units a little away\n * from walls (`engage`, the stances pack, and where an attacker stands by a building)\n *\n * @beta\n */\nexport const STRUCTURE_REACH = 0.4\n/** Spots on a ring at most: past that, room is there for everyone */\nconst MOST_SLOTS = 48\n/**\n * Seconds a target that could not be got at is left alone (see `shun`)\n *\n * @beta\n */\nexport const SHUN_TIME = 4\n\n/**\n * The ring an attacker fights from, by its reach: 0 for the melee\n *\n * @beta\n */\nexport function bandOf(world: World, attacker: Entity): number {\n\treturn Math.floor(statsOf(world, attacker).attackRange / BAND)\n}\n\n/**\n * The layer an attacker fights from, as the game's rules say (`RuleSettings.combat.engageLayer`)\n *\n * @beta\n */\nexport function engageLayer(world: World, attacker: Entity): EngageLayer {\n\treturn world.settings.combat.engageLayer(world, attacker)\n}\n\n/**\n * The engine's: from the air for what flies, from the water for boats, from the ground for the rest\n *\n * @beta\n */\nexport function defaultEngageLayer(_world: World, attacker: Entity): EngageLayer {\n\treturn attacker.flying ? 'air' : attacker.def.naval ? 'water' : 'ground'\n}\n\n/**\n * The engine's room around a target for attackers like this one: as many as stand side by side around it, on the ring\n * they fight from. Few for the melee around a footman, many around a town hall, all of them for long guns\n *\n * @beta\n */\nexport function defaultEngageRoom(world: World, target: Entity, attacker: Entity): number {\n\tconst reach = rangeAgainst(world, attacker, target)\n\tconst width = attacker.def.radius * 2 + 0.15\n\tconst footprint = target.def.footprint\n\tconst edge = footprint ? 2 * (footprint.w + footprint.d) : 2 * Math.PI * target.def.radius\n\treturn Math.max(1, Math.floor((edge + 2 * Math.PI * (attacker.def.radius + reach)) / width))\n}\n\n/**\n * How many attackers like this one may fight the target at once, as the game's rules say (`RuleSettings.combat.engageRoom`)\n *\n * @beta\n */\nexport function roomFor(world: World, target: Entity, attacker: Entity): number {\n\treturn world.settings.combat.engageRoom(world, target, attacker)\n}\n\n/**\n * Those engaged with one target: all of them, in the order they came, and by ring (`Ring`) once the target is asked\n * who holds what around it\n */\ninterface Engaged {\n\tall: Entity[]\n\trings: Ring[] | undefined\n}\n\n/**\n * Those of one layer and one band engaged with a target, worked out once a tick per target when first asked: an\n * attacker's band is its stats', and a crowd round one target asked that of every other, each of them, every tick.\n * And the spots they hold, by how many there are round it (`heldSlots`), worked out again once one of those engaged\n * with the target takes or lets go of one: the crowd that waits for room asks every tick, and the spots seldom change\n */\ninterface Ring {\n\tlayer: EngageLayer\n\tband: number\n\tmembers: Entity[]\n\theld: Map<number, Set<number>>\n}\n\n/** Who is engaged with whom, worked out again once a tick, when first asked */\nconst index = new WeakMap<World, { tick: number; by: Map<EntityId, Engaged> }>()\n\nfunction engagements(world: World): Map<EntityId, Engaged> {\n\tlet cached = index.get(world)\n\tif (cached?.tick === world.tick) return cached.by\n\tif (!cached) index.set(world, (cached = { tick: world.tick, by: new Map() }))\n\tcached.tick = world.tick\n\tcached.by.clear()\n\tfor (const entity of world.units.values()) {\n\t\tconst target = entity.get(fighting)?.engaged\n\t\tif (!target || !entity.alive) continue\n\t\tconst engaged = cached.by.get(target)\n\t\tif (engaged) engaged.all.push(entity)\n\t\telse cached.by.set(target, { all: [entity], rings: undefined })\n\t}\n\treturn cached.by\n}\n\n/** Puts the attacker on the list of what it is engaged with now, in this tick's index: others picking in the same tick see it at once */\nfunction enlist(world: World, attacker: Entity, target: Entity): void {\n\tconst by = engagements(world)\n\tconst engaged = by.get(target.id)\n\tif (!engaged) by.set(target.id, { all: [attacker], rings: undefined })\n\telse {\n\t\tengaged.all.push(attacker)\n\t\tif (engaged.rings) join(engaged.rings, attacker, engageLayer(world, attacker), bandOf(world, attacker))\n\t\tmoved(world, target.id)\n\t}\n}\n\n/** Takes the attacker off the list of what it was engaged with, in this tick's index */\nfunction unlist(world: World, attacker: Entity): void {\n\tconst id = attacker.get(fighting)?.engaged\n\tconst cached = index.get(world)\n\tif (!id || cached?.tick !== world.tick) return\n\tconst engaged = cached.by.get(id)\n\tif (!engaged || !drop(engaged.all, attacker) || !engaged.rings) return\n\tfor (const ring of engaged.rings) if (drop(ring.members, attacker)) break\n\tmoved(world, id)\n}\n\n/** Takes the first of the attacker off the list: whether it was on it */\nfunction drop(list: Entity[], attacker: Entity): boolean {\n\tconst at = list.indexOf(attacker)\n\tif (at >= 0) list.splice(at, 1)\n\treturn at >= 0\n}\n\n/** Adds the attacker to its ring of those round a target, making the ring when it is the first of it */\nfunction join(rings: Ring[], attacker: Entity, layer: EngageLayer, band: number): void {\n\tfor (const ring of rings) {\n\t\tif (ring.layer !== layer || ring.band !== band) continue\n\t\tring.members.push(attacker)\n\t\treturn\n\t}\n\trings.push({ layer, band, members: [attacker], held: new Map() })\n}\n\n/** Forgets the spots held round a target as this tick's index has them: one engaged with it took or let go of one */\nfunction moved(world: World, target: EntityId): void {\n\tconst cached = index.get(world)\n\tif (cached?.tick !== world.tick) return\n\tfor (const ring of cached.by.get(target)?.rings ?? []) ring.held.clear()\n}\n\n/** The ring of those engaged with the target of an attacker of that layer and band, the attacker in it if it is one */\nfunction ringOf(world: World, target: Entity, layer: EngageLayer, band: number): Ring | undefined {\n\tconst engaged = engagements(world).get(target.id)\n\tif (!engaged) return undefined\n\tif (!engaged.rings) {\n\t\tengaged.rings = []\n\t\tfor (const other of engaged.all) join(engaged.rings, other, engageLayer(world, other), bandOf(world, other))\n\t}\n\tfor (const ring of engaged.rings) if (ring.layer === layer && ring.band === band) return ring\n\treturn undefined\n}\n\n/**\n * Everyone fighting the target or closing in on it: of one layer only, when one is named\n *\n * @beta\n */\nexport function attackersOf(world: World, target: Entity, layer?: EngageLayer): Entity[] {\n\tconst all = engagements(world).get(target.id)?.all ?? []\n\treturn layer === undefined ? [...all] : all.filter((attacker) => engageLayer(world, attacker) === layer)\n}\n\n/**\n * How many attackers like this one (the same layer, the same ring) the target has already, the attacker left out\n *\n * @beta\n */\nexport function engagedLike(world: World, target: Entity, attacker: Entity): number {\n\tconst ring = ringOf(world, target, engageLayer(world, attacker), bandOf(world, attacker))\n\tlet count = 0\n\tif (ring) for (const other of ring.members) if (other !== attacker) count++\n\treturn count\n}\n\n/**\n * Whether the target has no room left for another attacker like this one\n *\n * @beta\n */\nexport function isCrowded(world: World, target: Entity, attacker: Entity): boolean {\n\treturn engagedLike(world, target, attacker) >= roomFor(world, target, attacker)\n}\n\n/**\n * What the attacker is fighting or closing in on, if anything\n *\n * @beta\n */\nexport function engagedWith(world: World, attacker: Entity): Entity | undefined {\n\tconst id = attacker.get(fighting)?.engaged\n\treturn id ? world.get(id) : undefined\n}\n\n/**\n * Marks the attacker engaged with the target, giving it a spot around it when it fights from close by (and has none\n * there yet). The engine does this as a unit fights or closes in; a game's own fighting can too\n *\n * @beta\n */\nexport function engageWith(world: World, attacker: Entity, target: Entity): void {\n\tconst combat = attacker.get(fighting)\n\tif (!combat) return\n\tif (combat.engaged === target.id && combat.slot !== null) return\n\tif (combat.engaged !== target.id) {\n\t\tunlist(world, attacker)\n\t\tenlist(world, attacker, target)\n\t}\n\tconst had = combat.slot\n\tcombat.engaged = target.id\n\tcombat.slot = null\n\t// what flies goes over, what hits a building goes to its nearest side: no spot to keep. None either when the ring is\n\t// full: it waits (`holdOff`) rather than take a place that is held\n\tif (!attacker.flying && !target.def.footprint) combat.slot = chooseSlot(world, attacker, target)\n\tif (combat.slot !== had) moved(world, target.id)\n}\n\n/**\n * Gives the attacker engaged with the target the spot round it at that angle, seen from it: where one that waited for\n * room goes in to (`holdOff`)\n *\n * @internal\n */\nexport function takeSpot(world: World, attacker: Entity, target: Entity, angle: number): void {\n\tconst combat = attacker.get(fighting)\n\tif (!combat) return\n\tcombat.slot = angle\n\tmoved(world, target.id)\n}\n\n/**\n * Lets go of whatever the attacker was engaged with, and of its spot there. Without the world, the rest of the tick\n * still counts it there, with its spot\n *\n * @beta\n */\nexport function release(attacker: Entity, world?: World): void {\n\tconst combat = attacker.get(fighting)\n\tif (!combat) return\n\tif (world && combat.engaged) unlist(world, attacker)\n\tcombat.engaged = 0\n\tcombat.slot = null\n}\n\n/** The spots others hold on the ring of an attacker that holds one there too: filled again for each such ask */\nconst others = new Set<number>()\nconst nowhere: ReadonlySet<number> = new Set()\n\n/**\n * The spots of the attacker's ring around the target that others like it hold, by number: `count` of them round it, the\n * first straight down the z axis from the target\n *\n * @internal\n */\nexport function heldSlots(world: World, attacker: Entity, target: Entity, count: number): ReadonlySet<number> {\n\tconst ring = ringOf(world, target, engageLayer(world, attacker), bandOf(world, attacker))\n\tif (!ring) return nowhere\n\t// one with no spot of its own (one asking for one, `engageWith`) has nothing of its own to leave out: what the ring\n\t// holds, as worked out already\n\tconst own = attacker.get(fighting)?.slot\n\tif (own !== null && own !== undefined) return spotsHeld(ring.members, attacker, count, others)\n\tlet held = ring.held.get(count)\n\tif (!held) ring.held.set(count, (held = spotsHeld(ring.members, attacker, count, new Set())))\n\treturn held\n}\n\n/** The spots, of `count` round a target, that those on a ring hold, the attacker left out: into `into`, emptied first */\nfunction spotsHeld(members: readonly Entity[], attacker: Entity, count: number, into: Set<number>): Set<number> {\n\tconst step = (Math.PI * 2) / count\n\tinto.clear()\n\tfor (const other of members) {\n\t\tconst slot = other.get(fighting)?.slot\n\t\tif (other === attacker || slot === null || slot === undefined) continue\n\t\tinto.add(((Math.round(slot / step) % count) + count) % count)\n\t}\n\treturn into\n}\n\n/** The direction the attacker is in, seen from the target: an angle about the up axis */\nfunction angleFrom(attacker: Entity, target: Entity): number {\n\t// `+ 0` makes a -0 (the round of a small negative, an angle of nothing below the axis) 0: a save writes -0 as 0, and a\n\t// loaded game must hold what the game it was saved from holds\n\treturn atan2(attacker.pos.x - target.pos.x, attacker.pos.z - target.pos.z) + 0\n}\n\n/**\n * The k-th spot by number out from the nearest, one side and then the other: the nearest, the one past it, the one\n * before it, two past it, and so on (the nearest as it is: a -0 stays one, as an angle of it did)\n */\nconst outFrom = (nearest: number, k: number): number => (k % 2 ? nearest + (k + 1) / 2 : nearest - k / 2)\n\n/**\n * A free spot around the target for the attacker, as an angle seen from the target: the one nearest the side it comes\n * from, of those on its ring that no one like it holds. None when every one is held: never one held already\n */\nfunction chooseSlot(world: World, attacker: Entity, target: Entity): number | null {\n\tconst from = angleFrom(attacker, target)\n\tconst count = Math.min(roomFor(world, target, attacker), MOST_SLOTS)\n\tconst held = heldSlots(world, attacker, target, Math.max(count, 1))\n\tif (count <= 1) return held.size ? null : from\n\tconst step = (Math.PI * 2) / count\n\tconst nearest = Math.round(from / step)\n\tfor (let k = 0; k <= 2 * Math.floor(count / 2); k++) {\n\t\tconst at = outFrom(nearest, k)\n\t\tif (!held.has(((at % count) + count) % count)) return at * step + 0\n\t}\n\treturn null\n}\n\n/**\n * Where the attacker goes to fight the target from: its spot around it, out where its weapon reaches, or the target\n * itself without one. The game's `approach` hook has the last word\n *\n * @beta\n */\nexport function spotFor(world: World, attacker: Entity, target: Entity): Vec2 {\n\tconst slot = attacker.get(fighting)?.engaged === target.id ? attacker.get(fighting)!.slot : null\n\tlet point: Vec2 = target.pos\n\tif (slot !== null && slot !== undefined) {\n\t\t// on its side of the target and well inside its reach, so that it walks on until it is in reach: units keep a\n\t\t// little more apart than they are wide, and a spot right at the edge of its reach is one it may never get to\n\t\tconst reach = rangeAgainst(world, attacker, target)\n\t\tconst out = Math.max(target.def.radius + attacker.def.radius + reach * 0.5 - 0.5, target.def.radius * 0.5)\n\t\tpoint = { x: target.pos.x + sin(slot) * out, z: target.pos.z + cos(slot) * out }\n\t}\n\tif (!world.hooks.has('approach')) return point\n\treturn world.hooks.run('approach', { attacker, target, point }).point\n}\n\n/**\n * Whether the attacker has been closing in on the target for longer than the game lets it (`RuleSettings.combat.giveUpChase`) without getting closer\n *\n * @beta\n */\nexport function isBlocked(world: World, attacker: Entity, target: Entity): boolean {\n\tconst m = attacker.get(moving)\n\tif (!m || m.goalEntity !== target.id) return false\n\tconst stalled = m.status === 'failed' ? Infinity : m.status === 'moving' ? m.stalledTime : 0\n\treturn stalled > world.settings.combat.giveUpChase(world, attacker, target)\n}\n\n/**\n * Has the attacker leave the target alone for a while: not picked by itself again until then\n *\n * @beta\n */\nexport function shun(world: World, attacker: Entity, target: Entity, seconds = SHUN_TIME): void {\n\tconst combat = attacker.get(fighting)\n\tif (!combat) return\n\tconst until = world.time + seconds\n\tcombat.shunned = (combat.shunned ?? []).filter(([id, end]) => id !== target.id && end > world.time)\n\tcombat.shunned.push([target.id, until])\n}\n\n/**\n * Whether the attacker leaves the target alone for now (see `shun`)\n *\n * @beta\n */\nexport function isShunned(world: World, attacker: Entity, target: Entity): boolean {\n\tconst shunned = attacker.get(fighting)?.shunned\n\tif (!shunned?.length) return false\n\tfor (let i = 0; i < shunned.length; i++) if (shunned[i][0] === target.id && shunned[i][1] > world.time) return true\n\treturn false\n}\n\n/**\n * The engine's distance from the middle of a target at which an attacker waits for room there\n * (`RuleSettings.combat.queueDistance`): just behind those fighting it, the target's size, two of the attacker, its reach\n * and half a cell out\n *\n * @beta\n */\nexport function defaultQueueDistance(world: World, attacker: Entity, target: Entity): number {\n\tconst footprint = target.def.footprint\n\tconst size = footprint ? hypot(footprint.w, footprint.d) / 2 : target.def.radius\n\treturn size + 2 * attacker.def.radius + rangeAgainst(world, attacker, target) + 0.5\n}\n\n/**\n * Where an attacker waits for room at a target (`holdOff`): out at the game's queue distance\n * (`RuleSettings.combat.queueDistance`) on its own side of it, or at `angle` (seen from the target, about the up axis), on\n * ground it can stand on\n *\n * @beta\n */\nexport function queuePoint(world: World, attacker: Entity, target: Entity, angle = angleFrom(attacker, target)): Vec2 {\n\tconst out = world.settings.combat.queueDistance(world, attacker, target)\n\tconst point = { x: target.pos.x + sin(angle) * out, z: target.pos.z + cos(angle) * out }\n\treturn world.navFor(attacker).closestPoint(point, 2) ?? point\n}\n\n/** What stands around a spot, asked of the grid again and again */\nconst around: Entity[] = []\n\n/**\n * Whether no one stands on the point for the attacker to stand there: no one but itself and its target, nor an ally that\n * would step aside for it (`RuleSettings.movement.makesWay`: standing about, or waiting as it does)\n */\nfunction standsFree(world: World, attacker: Entity, target: Entity, point: Vec2): boolean {\n\tconst radius = attacker.def.radius\n\tfor (const other of world.spatial.query(point.x, point.z, radius, around)) {\n\t\tif (other === attacker || other === target || !other.alive || other.hidden || other.flying) continue\n\t\tconst apart = other.def.footprint ? distanceToEdge(point, other) : hypot(other.pos.x - point.x, other.pos.z - point.z) - other.def.radius\n\t\t// anyone it would more than touch there stands in its place: a crowd's agents give a little\n\t\tif (apart >= radius * 0.85) continue\n\t\tif (!world.areAllies(attacker.owner, other.owner) || !world.settings.movement.makesWay(world, attacker, other)) return false\n\t}\n\treturn true\n}\n\n/**\n * Whether the attacker can walk straight to a point by a unit it fights: not through it, nor through anyone who would not\n * step aside for it on the way. (Round a building, the way round is the navigation's, and a walk held up is given up)\n */\nfunction clearWay(world: World, attacker: Entity, target: Entity, point: Vec2, origin: Vec2 = attacker.pos): boolean {\n\tif (target.def.footprint) return true\n\tconst radius = attacker.def.radius\n\tconst dx = point.x - origin.x\n\tconst dz = point.z - origin.z\n\tconst length = hypot(dx, dz)\n\tconst steps = Math.ceil(length / 0.5)\n\t// from a step off where it stands (what it stands among is no matter: it walks off) to the place itself\n\tfor (let i = 1; i <= steps; i++) {\n\t\tconst x = origin.x + (dx * i) / steps\n\t\tconst z = origin.z + (dz * i) / steps\n\t\tif (hypot(target.pos.x - x, target.pos.z - z) < target.def.radius + radius - 0.1) return false\n\t\tfor (const other of world.spatial.query(x, z, radius, around)) {\n\t\t\tif (other === attacker || other === target || !other.alive || other.hidden || other.flying || other.def.footprint) continue\n\t\t\tif (hypot(other.pos.x - x, other.pos.z - z) >= other.def.radius + radius - 0.1) continue\n\t\t\tif (!world.areAllies(attacker.owner, other.owner) || !world.settings.movement.makesWay(world, attacker, other)) return false\n\t\t}\n\t}\n\treturn true\n}\n\n/** The queue point in the direction (x, z), of unit length, from the target */\nfunction queueAt(world: World, attacker: Entity, target: Entity, x: number, z: number): Vec2 {\n\tconst out = world.settings.combat.queueDistance(world, attacker, target)\n\treturn { x: target.pos.x + x * out, z: target.pos.z + z * out }\n}\n\n/**\n * Which way from the target the spots are that others like the attacker are on their way to (`spotFor`'s), as x, z\n * pairs of unit length: filled again by every `findSpot`\n */\nconst heading: number[] = []\n\n/** Whether a place out at `out` in the direction (x, z) from the target is less than `width` from a spot in `heading` */\nfunction headedFor(x: number, z: number, out: number, width: number): boolean {\n\tfor (let i = 0; i < heading.length; i += 2) if (hypot(heading[i] - x, heading[i + 1] - z) * out < width) return true\n\treturn false\n}\n\n/** The place `findSpot` tries, made again for each: copied when it is the one */\nconst trying: Vec2 = { x: 0, z: 0 }\n\n/**\n * Where the attacker could fight the target from now: a place with room for it (`isCrowded`) where no one stands, nor\n * is on the way to: round a unit on its ring, round a building by its sides, the nearest its own side first. `straight`\n * (the default): only one it can walk straight to without pushing through those fighting a unit (round a building, the\n * way round is the navigation's); false: any, however far round. None when there is no room for it or every place is\n * taken; the target's own place for what flies. What an attacker waiting for room (`holdOff`) asks before it goes in\n *\n * @beta\n */\nexport function freeSpot(world: World, attacker: Entity, target: Entity, straight = true): Vec2 | undefined {\n\treturn findSpot(world, attacker, target, straight ? 'straight' : 'any')\n}\n\n/**\n * The nearest place by angle from the attacker's side, of those with room for it, that it can go in to from outside\n * those fighting the target (from the queue point at its angle): where an attacker whose own side is held goes round the\n * ring to (`holdOff`). Whether it can walk straight there from where it stands is not asked\n *\n * @internal\n */\nexport function ringSpot(world: World, attacker: Entity, target: Entity): Vec2 | undefined {\n\treturn findSpot(world, attacker, target, 'ring')\n}\n\n/**\n * Whether an ally anchored in a fight stands on the straight way from the attacker to the place it would fight its unit\n * target from (`spotFor`, the `approach` hook's point): what an attacker coming in on a held side finds out before it\n * walks into their backs\n *\n * @internal\n */\nexport function anchoredInWay(world: World, attacker: Entity, target: Entity): boolean {\n\tconst slot = attacker.get(fighting)?.slot\n\tif (slot === null || slot === undefined || target.def.footprint || attacker.flying) return false\n\tconst spot = spotFor(world, attacker, target)\n\tconst dx = spot.x - attacker.pos.x\n\tconst dz = spot.z - attacker.pos.z\n\tconst length = hypot(dx, dz)\n\t// far off, the way is for the navigation to find\n\tif (length > 12) return false\n\tconst radius = attacker.def.radius\n\tconst steps = Math.ceil(length / 0.5)\n\tfor (let i = 1; i <= steps; i++) {\n\t\tconst x = attacker.pos.x + (dx * i) / steps\n\t\tconst z = attacker.pos.z + (dz * i) / steps\n\t\tfor (const other of world.spatial.query(x, z, radius, around)) {\n\t\t\tif (other === attacker || other === target || !other.alive || other.hidden || other.flying || other.def.footprint) continue\n\t\t\tif (!other.get(moving)?.anchored || !world.areAllies(attacker.owner, other.owner)) continue\n\t\t\tif (hypot(other.pos.x - x, other.pos.z - z) < other.def.radius + radius - 0.1) return true\n\t\t}\n\t}\n\treturn false\n}\n\nfunction findSpot(world: World, attacker: Entity, target: Entity, way: 'any' | 'straight' | 'ring'): Vec2 | undefined {\n\tif (isCrowded(world, target, attacker)) return undefined\n\tif (attacker.flying) return target.pos\n\tconst reach = rangeAgainst(world, attacker, target)\n\tconst footprint = target.def.footprint\n\t// where it stands to hit it: out from a building's sides, or from a unit's edge, by its size and most of the way it\n\t// stops at (`engage`: a little inside its reach, the more for a building's edge)\n\tconst margin = attacker.def.radius + Math.max(reach + (footprint ? STRUCTURE_REACH : 0) - 0.15, 0.05)\n\tconst out = target.def.radius + margin\n\tconst width = attacker.def.radius * 2 + 0.15\n\t// places a quarter of a unit's width apart all the way round: those fighting stand where they got in reach, not on a grid\n\tconst count = Math.max(8, Math.floor((footprint ? 2 * (footprint.w + footprint.d) + 2 * Math.PI * margin : 2 * Math.PI * out) / (width / 4)))\n\tconst step = (Math.PI * 2) / count\n\t// those like it on their way to their spots round a unit: their places are taken\n\theading.length = 0\n\tif (!footprint) {\n\t\tfor (const other of ringOf(world, target, engageLayer(world, attacker), bandOf(world, attacker))?.members ?? []) {\n\t\t\tconst slot = other.get(fighting)?.slot\n\t\t\tif (other === attacker || slot === null || slot === undefined || other.get(moving)?.status !== 'moving') continue\n\t\t\theading.push(sin(slot), cos(slot))\n\t\t}\n\t}\n\tconst hooked = world.hooks.has('approach')\n\tconst nearest = Math.round(angleFrom(attacker, target) / step)\n\tfor (let k = 0; k <= 2 * Math.floor(count / 2); k++) {\n\t\tconst angle = outFrom(nearest, k) * step\n\t\tconst x = sin(angle)\n\t\tconst z = cos(angle)\n\t\tif (headedFor(x, z, out, width)) continue\n\t\ttrying.x = target.pos.x + x * out\n\t\ttrying.z = target.pos.z + z * out\n\t\tlet point = footprint ? closestPointOnRect(trying, target.rect, margin) : trying\n\t\t// the game's `approach` hook sees the place as it would take it, so that a flank it asks for is the one tried\n\t\tif (!footprint && hooked) point = world.hooks.run('approach', { attacker, target, point: { x: trying.x, z: trying.z } }).point\n\t\tif (!standsFree(world, attacker, target, point)) continue\n\t\tif (way !== 'any' && !clearWay(world, attacker, target, point, way === 'straight' ? attacker.pos : queueAt(world, attacker, target, x, z)))\n\t\t\tcontinue\n\t\treturn point === trying ? { x: trying.x, z: trying.z } : point\n\t}\n\treturn undefined\n}\n"],"mappings":";;;;;;;AA+BA,IAAM,OAAO;;;;;;;AAOb,IAAa,kBAAkB;;AAE/B,IAAM,aAAa;;;;;;AAMnB,IAAa,YAAY;;;;;;AAOzB,SAAgB,OAAO,OAAc,UAA0B;CAC9D,OAAO,KAAK,MAAM,QAAQ,OAAO,QAAQ,CAAC,CAAC,cAAc,IAAI;AAC9D;;;;;;AAOA,SAAgB,YAAY,OAAc,UAA+B;CACxE,OAAO,MAAM,SAAS,OAAO,YAAY,OAAO,QAAQ;AACzD;;;;;;AAOA,SAAgB,mBAAmB,QAAe,UAA+B;CAChF,OAAO,SAAS,SAAS,QAAQ,SAAS,IAAI,QAAQ,UAAU;AACjE;;;;;;;AAQA,SAAgB,kBAAkB,OAAc,QAAgB,UAA0B;CACzF,MAAM,QAAQ,aAAa,OAAO,UAAU,MAAM;CAClD,MAAM,QAAQ,SAAS,IAAI,SAAS,IAAI;CACxC,MAAM,YAAY,OAAO,IAAI;CAC7B,MAAM,OAAO,YAAY,KAAK,UAAU,IAAI,UAAU,KAAK,IAAI,KAAK,KAAK,OAAO,IAAI;CACpF,OAAO,KAAK,IAAI,GAAG,KAAK,OAAO,OAAO,IAAI,KAAK,MAAM,SAAS,IAAI,SAAS,UAAU,KAAK,CAAC;AAC5F;;;;;;AAOA,SAAgB,QAAQ,OAAc,QAAgB,UAA0B;CAC/E,OAAO,MAAM,SAAS,OAAO,WAAW,OAAO,QAAQ,QAAQ;AAChE;;AAyBA,IAAM,wBAAQ,IAAI,QAA6D;AAE/E,SAAS,YAAY,OAAsC;CAC1D,IAAI,SAAS,MAAM,IAAI,KAAK;CAC5B,IAAI,QAAQ,SAAS,MAAM,MAAM,OAAO,OAAO;CAC/C,IAAI,CAAC,QAAQ,MAAM,IAAI,OAAQ,SAAS;EAAE,MAAM,MAAM;EAAM,oBAAI,IAAI,IAAI;CAAE,CAAE;CAC5E,OAAO,OAAO,MAAM;CACpB,OAAO,GAAG,MAAM;CAChB,KAAK,MAAM,UAAU,MAAM,MAAM,OAAO,GAAG;EAC1C,MAAM,SAAS,OAAO,IAAI,QAAQ,CAAC,EAAE;EACrC,IAAI,CAAC,UAAU,CAAC,OAAO,OAAO;EAC9B,MAAM,UAAU,OAAO,GAAG,IAAI,MAAM;EACpC,IAAI,SAAS,QAAQ,IAAI,KAAK,MAAM;OAC/B,OAAO,GAAG,IAAI,QAAQ;GAAE,KAAK,CAAC,MAAM;GAAG,OAAO,KAAA;EAAU,CAAC;CAC/D;CACA,OAAO,OAAO;AACf;;AAGA,SAAS,OAAO,OAAc,UAAkB,QAAsB;CACrE,MAAM,KAAK,YAAY,KAAK;CAC5B,MAAM,UAAU,GAAG,IAAI,OAAO,EAAE;CAChC,IAAI,CAAC,SAAS,GAAG,IAAI,OAAO,IAAI;EAAE,KAAK,CAAC,QAAQ;EAAG,OAAO,KAAA;CAAU,CAAC;MAChE;EACJ,QAAQ,IAAI,KAAK,QAAQ;EACzB,IAAI,QAAQ,OAAO,KAAK,QAAQ,OAAO,UAAU,YAAY,OAAO,QAAQ,GAAG,OAAO,OAAO,QAAQ,CAAC;EACtG,MAAM,OAAO,OAAO,EAAE;CACvB;AACD;;AAGA,SAAS,OAAO,OAAc,UAAwB;CACrD,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,EAAE;CACnC,MAAM,SAAS,MAAM,IAAI,KAAK;CAC9B,IAAI,CAAC,MAAM,QAAQ,SAAS,MAAM,MAAM;CACxC,MAAM,UAAU,OAAO,GAAG,IAAI,EAAE;CAChC,IAAI,CAAC,WAAW,CAAC,KAAK,QAAQ,KAAK,QAAQ,KAAK,CAAC,QAAQ,OAAO;CAChE,KAAK,MAAM,QAAQ,QAAQ,OAAO,IAAI,KAAK,KAAK,SAAS,QAAQ,GAAG;CACpE,MAAM,OAAO,EAAE;AAChB;;AAGA,SAAS,KAAK,MAAgB,UAA2B;CACxD,MAAM,KAAK,KAAK,QAAQ,QAAQ;CAChC,IAAI,MAAM,GAAG,KAAK,OAAO,IAAI,CAAC;CAC9B,OAAO,MAAM;AACd;;AAGA,SAAS,KAAK,OAAe,UAAkB,OAAoB,MAAoB;CACtF,KAAK,MAAM,QAAQ,OAAO;EACzB,IAAI,KAAK,UAAU,SAAS,KAAK,SAAS,MAAM;EAChD,KAAK,QAAQ,KAAK,QAAQ;EAC1B;CACD;CACA,MAAM,KAAK;EAAE;EAAO;EAAM,SAAS,CAAC,QAAQ;EAAG,sBAAM,IAAI,IAAI;CAAE,CAAC;AACjE;;AAGA,SAAS,MAAM,OAAc,QAAwB;CACpD,MAAM,SAAS,MAAM,IAAI,KAAK;CAC9B,IAAI,QAAQ,SAAS,MAAM,MAAM;CACjC,KAAK,MAAM,QAAQ,OAAO,GAAG,IAAI,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG,KAAK,KAAK,MAAM;AACxE;;AAGA,SAAS,OAAO,OAAc,QAAgB,OAAoB,MAAgC;CACjG,MAAM,UAAU,YAAY,KAAK,CAAC,CAAC,IAAI,OAAO,EAAE;CAChD,IAAI,CAAC,SAAS,OAAO,KAAA;CACrB,IAAI,CAAC,QAAQ,OAAO;EACnB,QAAQ,QAAQ,CAAC;EACjB,KAAK,MAAM,SAAS,QAAQ,KAAK,KAAK,QAAQ,OAAO,OAAO,YAAY,OAAO,KAAK,GAAG,OAAO,OAAO,KAAK,CAAC;CAC5G;CACA,KAAK,MAAM,QAAQ,QAAQ,OAAO,IAAI,KAAK,UAAU,SAAS,KAAK,SAAS,MAAM,OAAO;AAE1F;;;;;;AAOA,SAAgB,YAAY,OAAc,QAAgB,OAA+B;CACxF,MAAM,MAAM,YAAY,KAAK,CAAC,CAAC,IAAI,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC;CACvD,OAAO,UAAU,KAAA,IAAY,CAAC,GAAG,GAAG,IAAI,IAAI,QAAQ,aAAa,YAAY,OAAO,QAAQ,MAAM,KAAK;AACxG;;;;;;AAOA,SAAgB,YAAY,OAAc,QAAgB,UAA0B;CACnF,MAAM,OAAO,OAAO,OAAO,QAAQ,YAAY,OAAO,QAAQ,GAAG,OAAO,OAAO,QAAQ,CAAC;CACxF,IAAI,QAAQ;CACZ,IAAI,MAAW;OAAA,MAAM,SAAS,KAAK,SAAS,IAAI,UAAU,UAAU;CAAA;CACpE,OAAO;AACR;;;;;;AAOA,SAAgB,UAAU,OAAc,QAAgB,UAA2B;CAClF,OAAO,YAAY,OAAO,QAAQ,QAAQ,KAAK,QAAQ,OAAO,QAAQ,QAAQ;AAC/E;;;;;;AAOA,SAAgB,YAAY,OAAc,UAAsC;CAC/E,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,EAAE;CACnC,OAAO,KAAK,MAAM,IAAI,EAAE,IAAI,KAAA;AAC7B;;;;;;;AAQA,SAAgB,WAAW,OAAc,UAAkB,QAAsB;CAChF,MAAM,SAAS,SAAS,IAAI,QAAQ;CACpC,IAAI,CAAC,QAAQ;CACb,IAAI,OAAO,YAAY,OAAO,MAAM,OAAO,SAAS,MAAM;CAC1D,IAAI,OAAO,YAAY,OAAO,IAAI;EACjC,OAAO,OAAO,QAAQ;EACtB,OAAO,OAAO,UAAU,MAAM;CAC/B;CACA,MAAM,MAAM,OAAO;CACnB,OAAO,UAAU,OAAO;CACxB,OAAO,OAAO;CAGd,IAAI,CAAC,SAAS,UAAU,CAAC,OAAO,IAAI,WAAW,OAAO,OAAO,WAAW,OAAO,UAAU,MAAM;CAC/F,IAAI,OAAO,SAAS,KAAK,MAAM,OAAO,OAAO,EAAE;AAChD;;;;;;;AAQA,SAAgB,SAAS,OAAc,UAAkB,QAAgB,OAAqB;CAC7F,MAAM,SAAS,SAAS,IAAI,QAAQ;CACpC,IAAI,CAAC,QAAQ;CACb,OAAO,OAAO;CACd,MAAM,OAAO,OAAO,EAAE;AACvB;;;;;;;AAQA,SAAgB,QAAQ,UAAkB,OAAqB;CAC9D,MAAM,SAAS,SAAS,IAAI,QAAQ;CACpC,IAAI,CAAC,QAAQ;CACb,IAAI,SAAS,OAAO,SAAS,OAAO,OAAO,QAAQ;CACnD,OAAO,UAAU;CACjB,OAAO,OAAO;AACf;;AAGA,IAAM,yBAAS,IAAI,IAAY;AAC/B,IAAM,0BAA+B,IAAI,IAAI;;;;;;;AAQ7C,SAAgB,UAAU,OAAc,UAAkB,QAAgB,OAAoC;CAC7G,MAAM,OAAO,OAAO,OAAO,QAAQ,YAAY,OAAO,QAAQ,GAAG,OAAO,OAAO,QAAQ,CAAC;CACxF,IAAI,CAAC,MAAM,OAAO;CAGlB,MAAM,MAAM,SAAS,IAAI,QAAQ,CAAC,EAAE;CACpC,IAAI,QAAQ,QAAQ,QAAQ,KAAA,GAAW,OAAO,UAAU,KAAK,SAAS,UAAU,OAAO,MAAM;CAC7F,IAAI,OAAO,KAAK,KAAK,IAAI,KAAK;CAC9B,IAAI,CAAC,MAAM,KAAK,KAAK,IAAI,OAAQ,OAAO,UAAU,KAAK,SAAS,UAAU,uBAAO,IAAI,IAAI,CAAC,CAAE;CAC5F,OAAO;AACR;;AAGA,SAAS,UAAU,SAA4B,UAAkB,OAAe,MAAgC;CAC/G,MAAM,OAAQ,KAAK,KAAK,IAAK;CAC7B,KAAK,MAAM;CACX,KAAK,MAAM,SAAS,SAAS;EAC5B,MAAM,OAAO,MAAM,IAAI,QAAQ,CAAC,EAAE;EAClC,IAAI,UAAU,YAAY,SAAS,QAAQ,SAAS,KAAA,GAAW;EAC/D,KAAK,KAAM,KAAK,MAAM,OAAO,IAAI,IAAI,QAAS,SAAS,KAAK;CAC7D;CACA,OAAO;AACR;;AAGA,SAAS,UAAU,UAAkB,QAAwB;CAG5D,OAAO,MAAM,SAAS,IAAI,IAAI,OAAO,IAAI,GAAG,SAAS,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI;AAC9E;;;;;AAMA,IAAM,WAAW,SAAiB,MAAuB,IAAI,IAAI,WAAW,IAAI,KAAK,IAAI,UAAU,IAAI;;;;;AAMvG,SAAS,WAAW,OAAc,UAAkB,QAA+B;CAClF,MAAM,OAAO,UAAU,UAAU,MAAM;CACvC,MAAM,QAAQ,KAAK,IAAI,QAAQ,OAAO,QAAQ,QAAQ,GAAG,UAAU;CACnE,MAAM,OAAO,UAAU,OAAO,UAAU,QAAQ,KAAK,IAAI,OAAO,CAAC,CAAC;CAClE,IAAI,SAAS,GAAG,OAAO,KAAK,OAAO,OAAO;CAC1C,MAAM,OAAQ,KAAK,KAAK,IAAK;CAC7B,MAAM,UAAU,KAAK,MAAM,OAAO,IAAI;CACtC,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,KAAK,MAAM,QAAQ,CAAC,GAAG,KAAK;EACpD,MAAM,KAAK,QAAQ,SAAS,CAAC;EAC7B,IAAI,CAAC,KAAK,KAAM,KAAK,QAAS,SAAS,KAAK,GAAG,OAAO,KAAK,OAAO;CACnE;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,QAAQ,OAAc,UAAkB,QAAsB;CAC7E,MAAM,OAAO,SAAS,IAAI,QAAQ,CAAC,EAAE,YAAY,OAAO,KAAK,SAAS,IAAI,QAAQ,CAAC,CAAE,OAAO;CAC5F,IAAI,QAAc,OAAO;CACzB,IAAI,SAAS,QAAQ,SAAS,KAAA,GAAW;EAGxC,MAAM,QAAQ,aAAa,OAAO,UAAU,MAAM;EAClD,MAAM,MAAM,KAAK,IAAI,OAAO,IAAI,SAAS,SAAS,IAAI,SAAS,QAAQ,KAAM,IAAK,OAAO,IAAI,SAAS,EAAG;EACzG,QAAQ;GAAE,GAAG,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI;GAAK,GAAG,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI;EAAI;CAChF;CACA,IAAI,CAAC,MAAM,MAAM,IAAI,UAAU,GAAG,OAAO;CACzC,OAAO,MAAM,MAAM,IAAI,YAAY;EAAE;EAAU;EAAQ;CAAM,CAAC,CAAC,CAAC;AACjE;;;;;;AAOA,SAAgB,UAAU,OAAc,UAAkB,QAAyB;CAClF,MAAM,IAAI,SAAS,IAAI,MAAM;CAC7B,IAAI,CAAC,KAAK,EAAE,eAAe,OAAO,IAAI,OAAO;CAE7C,QADgB,EAAE,WAAW,WAAW,WAAW,EAAE,WAAW,WAAW,EAAE,cAAc,KAC1E,MAAM,SAAS,OAAO,YAAY,OAAO,UAAU,MAAM;AAC3E;;;;;;AAOA,SAAgB,KAAK,OAAc,UAAkB,QAAgB,UAAA,GAA2B;CAC/F,MAAM,SAAS,SAAS,IAAI,QAAQ;CACpC,IAAI,CAAC,QAAQ;CACb,MAAM,QAAQ,MAAM,OAAO;CAC3B,OAAO,WAAW,OAAO,WAAW,CAAC,EAAA,CAAG,QAAQ,CAAC,IAAI,SAAS,OAAO,OAAO,MAAM,MAAM,MAAM,IAAI;CAClG,OAAO,QAAQ,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC;AACvC;;;;;;AAOA,SAAgB,UAAU,OAAc,UAAkB,QAAyB;CAClF,MAAM,UAAU,SAAS,IAAI,QAAQ,CAAC,EAAE;CACxC,IAAI,CAAC,SAAS,QAAQ,OAAO;CAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,IAAI,QAAQ,EAAE,CAAC,OAAO,OAAO,MAAM,QAAQ,EAAE,CAAC,KAAK,MAAM,MAAM,OAAO;CAC/G,OAAO;AACR;;;;;;;;AASA,SAAgB,qBAAqB,OAAc,UAAkB,QAAwB;CAC5F,MAAM,YAAY,OAAO,IAAI;CAE7B,QADa,YAAY,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,IAAI,OAAO,IAAI,UAC5D,IAAI,SAAS,IAAI,SAAS,aAAa,OAAO,UAAU,MAAM,IAAI;AACjF;;;;;;;;AASA,SAAgB,WAAW,OAAc,UAAkB,QAAgB,QAAQ,UAAU,UAAU,MAAM,GAAS;CACrH,MAAM,MAAM,MAAM,SAAS,OAAO,cAAc,OAAO,UAAU,MAAM;CACvE,MAAM,QAAQ;EAAE,GAAG,OAAO,IAAI,IAAI,IAAI,KAAK,IAAI;EAAK,GAAG,OAAO,IAAI,IAAI,IAAI,KAAK,IAAI;CAAI;CACvF,OAAO,MAAM,OAAO,QAAQ,CAAC,CAAC,aAAa,OAAO,CAAC,KAAK;AACzD;;AAGA,IAAM,SAAmB,CAAC;;;;;AAM1B,SAAS,WAAW,OAAc,UAAkB,QAAgB,OAAsB;CACzF,MAAM,SAAS,SAAS,IAAI;CAC5B,KAAK,MAAM,SAAS,MAAM,QAAQ,MAAM,MAAM,GAAG,MAAM,GAAG,QAAQ,MAAM,GAAG;EAC1E,IAAI,UAAU,YAAY,UAAU,UAAU,CAAC,MAAM,SAAS,MAAM,UAAU,MAAM,QAAQ;EAG5F,KAFc,MAAM,IAAI,YAAY,eAAe,OAAO,KAAK,IAAI,MAAM,MAAM,IAAI,IAAI,MAAM,GAAG,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,MAAM,IAAI,WAEtH,SAAS,KAAM;EAC5B,IAAI,CAAC,MAAM,UAAU,SAAS,OAAO,MAAM,KAAK,KAAK,CAAC,MAAM,SAAS,SAAS,SAAS,OAAO,UAAU,KAAK,GAAG,OAAO;CACxH;CACA,OAAO;AACR;;;;;AAMA,SAAS,SAAS,OAAc,UAAkB,QAAgB,OAAa,SAAe,SAAS,KAAc;CACpH,IAAI,OAAO,IAAI,WAAW,OAAO;CACjC,MAAM,SAAS,SAAS,IAAI;CAC5B,MAAM,KAAK,MAAM,IAAI,OAAO;CAC5B,MAAM,KAAK,MAAM,IAAI,OAAO;CAC5B,MAAM,SAAS,MAAM,IAAI,EAAE;CAC3B,MAAM,QAAQ,KAAK,KAAK,SAAS,EAAG;CAEpC,KAAK,IAAI,IAAI,GAAG,KAAK,OAAO,KAAK;EAChC,MAAM,IAAI,OAAO,IAAK,KAAK,IAAK;EAChC,MAAM,IAAI,OAAO,IAAK,KAAK,IAAK;EAChC,IAAI,MAAM,OAAO,IAAI,IAAI,GAAG,OAAO,IAAI,IAAI,CAAC,IAAI,OAAO,IAAI,SAAS,SAAS,IAAK,OAAO;EACzF,KAAK,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,GAAG,QAAQ,MAAM,GAAG;GAC9D,IAAI,UAAU,YAAY,UAAU,UAAU,CAAC,MAAM,SAAS,MAAM,UAAU,MAAM,UAAU,MAAM,IAAI,WAAW;GACnH,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,MAAM,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,SAAS,SAAS,IAAK;GAChF,IAAI,CAAC,MAAM,UAAU,SAAS,OAAO,MAAM,KAAK,KAAK,CAAC,MAAM,SAAS,SAAS,SAAS,OAAO,UAAU,KAAK,GAAG,OAAO;EACxH;CACD;CACA,OAAO;AACR;;AAGA,SAAS,QAAQ,OAAc,UAAkB,QAAgB,GAAW,GAAiB;CAC5F,MAAM,MAAM,MAAM,SAAS,OAAO,cAAc,OAAO,UAAU,MAAM;CACvE,OAAO;EAAE,GAAG,OAAO,IAAI,IAAI,IAAI;EAAK,GAAG,OAAO,IAAI,IAAI,IAAI;CAAI;AAC/D;;;;;AAMA,IAAM,UAAoB,CAAC;;AAG3B,SAAS,UAAU,GAAW,GAAW,KAAa,OAAwB;CAC7E,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG,QAAQ,IAAI,KAAK,CAAC,IAAI,MAAM,OAAO,OAAO;CAChH,OAAO;AACR;;AAGA,IAAM,SAAe;CAAE,GAAG;CAAG,GAAG;AAAE;;;;;;;;;;AAWlC,SAAgB,SAAS,OAAc,UAAkB,QAAgB,WAAW,MAAwB;CAC3G,OAAO,SAAS,OAAO,UAAU,QAAQ,WAAW,aAAa,KAAK;AACvE;;;;;;;;AASA,SAAgB,SAAS,OAAc,UAAkB,QAAkC;CAC1F,OAAO,SAAS,OAAO,UAAU,QAAQ,MAAM;AAChD;;;;;;;;AASA,SAAgB,cAAc,OAAc,UAAkB,QAAyB;CACtF,MAAM,OAAO,SAAS,IAAI,QAAQ,CAAC,EAAE;CACrC,IAAI,SAAS,QAAQ,SAAS,KAAA,KAAa,OAAO,IAAI,aAAa,SAAS,QAAQ,OAAO;CAC3F,MAAM,OAAO,QAAQ,OAAO,UAAU,MAAM;CAC5C,MAAM,KAAK,KAAK,IAAI,SAAS,IAAI;CACjC,MAAM,KAAK,KAAK,IAAI,SAAS,IAAI;CACjC,MAAM,SAAS,MAAM,IAAI,EAAE;CAE3B,IAAI,SAAS,IAAI,OAAO;CACxB,MAAM,SAAS,SAAS,IAAI;CAC5B,MAAM,QAAQ,KAAK,KAAK,SAAS,EAAG;CACpC,KAAK,IAAI,IAAI,GAAG,KAAK,OAAO,KAAK;EAChC,MAAM,IAAI,SAAS,IAAI,IAAK,KAAK,IAAK;EACtC,MAAM,IAAI,SAAS,IAAI,IAAK,KAAK,IAAK;EACtC,KAAK,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,GAAG,QAAQ,MAAM,GAAG;GAC9D,IAAI,UAAU,YAAY,UAAU,UAAU,CAAC,MAAM,SAAS,MAAM,UAAU,MAAM,UAAU,MAAM,IAAI,WAAW;GACnH,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,EAAE,YAAY,CAAC,MAAM,UAAU,SAAS,OAAO,MAAM,KAAK,GAAG;GACnF,IAAI,MAAM,MAAM,IAAI,IAAI,GAAG,MAAM,IAAI,IAAI,CAAC,IAAI,MAAM,IAAI,SAAS,SAAS,IAAK,OAAO;EACvF;CACD;CACA,OAAO;AACR;AAEA,SAAS,SAAS,OAAc,UAAkB,QAAgB,KAAoD;CACrH,IAAI,UAAU,OAAO,QAAQ,QAAQ,GAAG,OAAO,KAAA;CAC/C,IAAI,SAAS,QAAQ,OAAO,OAAO;CACnC,MAAM,QAAQ,aAAa,OAAO,UAAU,MAAM;CAClD,MAAM,YAAY,OAAO,IAAI;CAG7B,MAAM,SAAS,SAAS,IAAI,SAAS,KAAK,IAAI,SAAS,YAAY,kBAAkB,KAAK,KAAM,GAAI;CACpG,MAAM,MAAM,OAAO,IAAI,SAAS;CAChC,MAAM,QAAQ,SAAS,IAAI,SAAS,IAAI;CAExC,MAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,OAAO,YAAY,KAAK,UAAU,IAAI,UAAU,KAAK,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,QAAQ,QAAQ,EAAE,CAAC;CAC5I,MAAM,OAAQ,KAAK,KAAK,IAAK;CAE7B,QAAQ,SAAS;CACjB,IAAI,CAAC,WACJ,KAAK,MAAM,SAAS,OAAO,OAAO,QAAQ,YAAY,OAAO,QAAQ,GAAG,OAAO,OAAO,QAAQ,CAAC,CAAC,EAAE,WAAW,CAAC,GAAG;EAChH,MAAM,OAAO,MAAM,IAAI,QAAQ,CAAC,EAAE;EAClC,IAAI,UAAU,YAAY,SAAS,QAAQ,SAAS,KAAA,KAAa,MAAM,IAAI,MAAM,CAAC,EAAE,WAAW,UAAU;EACzG,QAAQ,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC;CAClC;CAED,MAAM,SAAS,MAAM,MAAM,IAAI,UAAU;CACzC,MAAM,UAAU,KAAK,MAAM,UAAU,UAAU,MAAM,IAAI,IAAI;CAC7D,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,KAAK,MAAM,QAAQ,CAAC,GAAG,KAAK;EACpD,MAAM,QAAQ,QAAQ,SAAS,CAAC,IAAI;EACpC,MAAM,IAAI,IAAI,KAAK;EACnB,MAAM,IAAI,IAAI,KAAK;EACnB,IAAI,UAAU,GAAG,GAAG,KAAK,KAAK,GAAG;EACjC,OAAO,IAAI,OAAO,IAAI,IAAI,IAAI;EAC9B,OAAO,IAAI,OAAO,IAAI,IAAI,IAAI;EAC9B,IAAI,QAAQ,YAAY,mBAAmB,QAAQ,OAAO,MAAM,MAAM,IAAI;EAE1E,IAAI,CAAC,aAAa,QAAQ,QAAQ,MAAM,MAAM,IAAI,YAAY;GAAE;GAAU;GAAQ,OAAO;IAAE,GAAG,OAAO;IAAG,GAAG,OAAO;GAAE;EAAE,CAAC,CAAC,CAAC;EACzH,IAAI,CAAC,WAAW,OAAO,UAAU,QAAQ,KAAK,GAAG;EACjD,IAAI,QAAQ,SAAS,CAAC,SAAS,OAAO,UAAU,QAAQ,OAAO,QAAQ,aAAa,SAAS,MAAM,QAAQ,OAAO,UAAU,QAAQ,GAAG,CAAC,CAAC,GACxI;EACD,OAAO,UAAU,SAAS;GAAE,GAAG,OAAO;GAAG,GAAG,OAAO;EAAE,IAAI;CAC1D;AAED"}