@v12-engine/engine 0.1.1 → 0.4.0

package/dist/abilities/effects.js

@@ -0,0 +1,860 @@
+import { atan2, cos, hypot, sin } from "../exactMath.js";
+import { dist } from "../math.js";
+import { at } from "../defs.js";
+import { manaChanged, missileHit, missileRemoved } from "../engineEvents.js";
+import { replicateEvent, snapshotField } from "../replication.js";
+import { distanceToEdge, moving } from "../entity.js";
+import { agentParamsOf } from "../navigation/agentParams.js";
+import { heroState } from "../hero.js";
+import { conditionHolds, hasTag } from "./chance.js";
+import { effectIndex } from "./effectIndex.js";
+import { land, reached, run } from "./land.js";
+import { avoids, hasBuff, isUntargetable, layerOf, removeBuff } from "./buffs.js";
+import { halt, setGhost } from "../systems/movement.js";
+import { dashing } from "../dashing.js";
+import { EFFECT_FIELDS } from "./effectFields.js";
+import { sortTargets } from "../query.js";
+import { areaReach, edgeRadius, effectArea, inArea } from "./shapes.js";
+//#region src/abilities/effects.ts
+/** Where an effect is in an ability of the registry, for the screen (`effectIndex`) */
+var effectIndexOf = (world, ability, effect) => world.registry.abilities.has(ability) ? effectIndex(world.registry.ability(ability), effect) : void 0;
+/**
+* A kind of effect, its type and what it does together: `defineEffect({ type: 'pull', run: (context, effect) => ... })`, listed in
+* `Rules.effects`. Its fields are said by declaring the type in `EffectTypes`
+* (`declare module '@v12-engine/engine' { interface EffectTypes { pull: { distance: number } } }`), so that a handler
+* reads them typed, and an ability's effect of the type is checked for them
+*
+* @public
+*/
+function defineEffect(def) {
+	const { type, run, ...options } = def;
+	const fields = options.fields?.flatMap((field) => typeof field === "string" ? EFFECT_FIELDS[field] ?? [] : [field]);
+	return {
+		type,
+		run,
+		of: (fields) => ({
+			...fields,
+			type
+		}),
+		...fields && { fields }
+	};
+}
+/** The unit effects go off from, where that is one and not the caster */
+var originUnit = (context) => context.origin && "pos" in context.origin && context.origin !== context.caster ? context.origin : void 0;
+var found = [];
+/**
+* Whether an effect may reach a target, as the game says (the `beforeEffect` hook): what a game's own effect asks of
+* each unit it does something to without `effectTargets` (which asks it of every one it gives). True where no handler is
+* there. `missile`: the missile that reached it, for a missile's hit
+*
+* @beta
+*/
+function mayReach(context, effect, target, missile) {
+	const { world, caster, ability, level, origin, point } = context;
+	if (!world.hooks.has("beforeEffect")) return true;
+	const event = {
+		caster,
+		ability,
+		level,
+		effect,
+		target,
+		origin,
+		point,
+		missile,
+		cancelled: false
+	};
+	return !world.hooks.run("beforeEffect", event).cancelled;
+}
+/**
+* Who an effect applies to: the caster (`on: 'caster'`), the target or the caster (no `radius`), or who is within its
+* `radius` of where it landed, as `affects` (`fallback` when it says nothing), `layers`, `kinds`, `tags`, `ifBuff`, `only` and
+* what keeps out of the ability's way (`avoids`) say, the unit it went off from aside (`EffectContext.origin`); and of
+* those, who the game lets it reach (`beforeEffect`, `mayReach`). A handler of a game's own effect calls it as the
+* engine's do: who it gives is told to `effectLanded` once the handler is done
+*
+* @beta
+*/
+function effectTargets(context, effect, fallback) {
+	const given = chosen(context, effect, candidates(context, effect, fallback));
+	const result = context.world.hooks.has("beforeEffect") ? given.filter((target) => mayReach(context, effect, target)) : given;
+	reached(result);
+	return result;
+}
+/**
+* Of who an effect's area reaches, those it goes to: in its `sort` (the nearest to the middle of its area, where it
+* landed, or the caster for a cone, a line and an arc, where it has a `limit` alone), as many as its `limit`, before
+* the game has its say
+*/
+function chosen(context, effect, given) {
+	const { sort, limit } = effect;
+	if (sort === void 0 && limit === void 0 || effect.on === "caster" || given.length === 0) return given;
+	const area = effectArea(context, effect);
+	if (!area) return given;
+	sortTargets(context.world, given, sort ?? "nearest", {
+		x: area.x,
+		z: area.z
+	});
+	if (limit !== void 0) given.length = Math.min(given.length, Math.max(0, Math.floor(at(limit, context.level))));
+	return given;
+}
+/** Whether an entity is one an effect applies to by its `ifBuff`, `only`, `kinds`, `tags` and `where` */
+var fitsCommon = (context, effect, entity) => (!effect.ifBuff || hasBuff(entity, effect.ifBuff)) && (effect.only !== "heroes" || entity.has(heroState)) && (!effect.kinds || effect.kinds.includes(entity.def.kind)) && (!effect.tags || hasTag(entity, effect.tags)) && (!effect.where || conditionHolds(context, effect.where, entity));
+/**
+* Of what an effect found to act on by itself (the `burn` effect: what burns where it lands, trees among it, which
+* `effectTargets` leaves out as resources), those it applies to as its fields of whom say (`EffectCommon`): `layers`,
+* `affects` (`fallback` when it says nothing), `ifBuff`, `only`, `kinds` (everything, resources too, when left out),
+* `tags`, `where`, and what keeps out of the ability's way (`avoids`); in its `sort`, as many as its `limit`; and of
+* those, who the game lets it reach (`beforeEffect`). Told to `effectLanded` as `effectTargets`'s are
+*
+* @internal
+*/
+function effectFilter(context, effect, things, fallback) {
+	const { world, caster } = context;
+	const { layers } = effect;
+	const affects = effect.affects ?? fallback;
+	const picked = chosen(context, effect, things.filter((entity) => (!layers || layers.includes(layerOf(world, entity))) && (affects !== "enemies" || world.areEnemies(caster.owner, entity.owner)) && (affects !== "allies" || world.areAllies(caster.owner, entity.owner)) && (entity === caster || !avoids(world, entity, context.ability)) && (entity === caster || !entity.buffs.length || !isUntargetable(world, entity)) && fitsCommon(context, effect, entity)));
+	const result = world.hooks.has("beforeEffect") ? picked.filter((target) => mayReach(context, effect, target)) : picked;
+	reached(result);
+	return result;
+}
+/** Who an effect applies to, by what it says (`effectTargets`), before the game has its say */
+function candidates(context, effect, fallback) {
+	const { world, caster, target, point } = context;
+	if (effect.on === "caster") return [caster];
+	const { layers } = effect;
+	const area = effectArea(context, effect);
+	const fits = (entity) => fitsCommon(context, effect, entity);
+	if (!area) {
+		const one = target ?? caster;
+		if (one !== caster && avoids(world, one, context.ability)) return [];
+		if (one !== caster && one.buffs.length && isUntargetable(world, one)) return [];
+		return (!layers || layers.includes(layerOf(world, one))) && fits(one) ? [one] : [];
+	}
+	const affects = effect.affects ?? fallback;
+	const result = [];
+	const origin = originUnit(context);
+	const circle = area.shape === "circle";
+	const radius = area.radius;
+	for (const entity of world.spatial.query(area.x, area.z, circle ? radius : areaReach(area), found)) {
+		if (!entity.alive || entity.hidden || entity.isResource || entity === origin) continue;
+		if (circle ? distanceToEdge(point, entity) > radius : !inArea(area, entity.pos, edgeRadius(entity))) continue;
+		if (layers && !layers.includes(layerOf(world, entity))) continue;
+		if (affects === "enemies" && !world.areEnemies(caster.owner, entity.owner)) continue;
+		if (affects === "allies" && !world.areAllies(caster.owner, entity.owner)) continue;
+		if (entity !== caster && avoids(world, entity, context.ability)) continue;
+		if (entity !== caster && entity.buffs.length && isUntargetable(world, entity)) continue;
+		if (fits(entity)) result.push(entity);
+	}
+	return result;
+}
+/** Whether an ability of the caster is charged: its `charge` buff is on it with as many stacks as it can have */
+function isCharged(world, caster, ability) {
+	if (!ability.charge) return false;
+	const instance = caster.buffs.find((carried) => carried.id === ability.charge);
+	return !!instance && (instance.stacks ?? 0) >= (world.registry.buff(ability.charge).maxStacks ?? 1);
+}
+/**
+* Takes someone off the ground for a leap or a throw. Up there it is nobody's obstacle: it pushes no one
+* on its way over them, and goes straight over what cannot be walked
+*/
+/**
+* Sends an entity rushing to a spot (`dash.x`, `dash.z`): nothing stops it on the way, its orders wait, and what
+* `dash.effects` do happens where it ends. A leap (`dash.height`) takes it off the ground until it comes down
+*
+* @beta
+*/
+function startDash(world, entity, dash) {
+	if (entity.isStructure) throw new Error(`${entity.def.id}#${entity.id} is a structure: it cannot rush anywhere`);
+	world.wake(entity);
+	entity.set(dashing, {
+		...dash,
+		from: {
+			x: entity.pos.x,
+			z: entity.pos.z
+		}
+	});
+	if (dash.height) takeOff(world, entity);
+}
+function takeOff(world, entity) {
+	if (!entity.get(moving)) return;
+	halt(world, entity);
+	world.nav.removeAgent(entity.id);
+}
+/** Back on the ground, where it came down */
+function touchDown(world, entity) {
+	const m = entity.get(moving);
+	if (!m) return;
+	world.nav.addAgent(entity.id, entity.pos, agentParamsOf(entity, m.speed));
+	const { ghost } = m;
+	m.ghost = false;
+	delete m.phased;
+	m.anchored = false;
+	m.status = "idle";
+	setGhost(world, entity, ghost);
+	const order = entity.orders[0];
+	if (order) order.started = false;
+}
+var crossed = [];
+/** Seconds between two rounds of a zone seeing to what is inside */
+var ZONE_INTERVAL = .25;
+/** Missiles taken out of the world while the missiles were being moved along: the round passes them by */
+var gone = /* @__PURE__ */ new WeakSet();
+/** Takes a missile out of the world, and tells it: false for one that was not in it */
+function drop(world, missile) {
+	const index = world.missiles.indexOf(missile);
+	if (index < 0) return false;
+	world.missiles.splice(index, 1);
+	gone.add(missile);
+	world.events.emit(missileRemoved, missile);
+	return true;
+}
+/**
+* Takes a missile of an ability out of the world before it is done: blocked by a wall of wind, caught, swallowed. It
+* hits nothing more, and every screen is told (`missileRemoved`). With `end`, what happens where it ends
+* (`EffectFields.onEnd`) happens where it is, as if it had come to the end of its way. False for one that is not in the
+* world (`world.missiles`) any more
+*
+* @beta
+*/
+function removeMissile(world, missile, options = {}) {
+	if (!drop(world, missile)) return false;
+	const caster = world.get(missile.source);
+	const ability = world.registry.abilities.has(missile.ability) ? world.registry.ability(missile.ability) : void 0;
+	if (options.end && caster && ability && missile.effect.onEnd) {
+		const point = {
+			x: missile.x,
+			z: missile.z
+		};
+		land({
+			world,
+			caster,
+			ability,
+			level: missile.level,
+			point,
+			distance: missile.travelled,
+			share: shareOf(missile),
+			held: missile.held
+		}, missile.effect.onEnd);
+	}
+	return true;
+}
+/**
+* Ends a zone of an ability (`world.zones`) before its time: what happens at its end (`onEnd`) happens now, unless
+* `onEnd` is false (a zone called off, not finished). False for one that is not in the world any more
+*
+* @beta
+*/
+function endZone(world, zone, options = {}) {
+	const index = world.zones.indexOf(zone);
+	if (index < 0) return false;
+	world.zones.splice(index, 1);
+	if (options.onEnd !== false) land(zoneContext(world, zone), zone.effect.onEnd);
+	return true;
+}
+/**
+* What a zone's effects run with: its caster, its place, the way it was cast (AB10)
+*
+* @internal
+*/
+var zoneContext = (world, zone) => ({
+	world,
+	caster: zone.caster,
+	ability: zone.ability,
+	level: zone.level,
+	point: {
+		x: zone.x,
+		z: zone.z
+	},
+	...zone.from && { origin: {
+		x: zone.from.x,
+		z: zone.from.z
+	} },
+	...zone.heading !== void 0 && { heading: zone.heading }
+});
+/** Whether a missile may hit an entity, as its effect says: who it is for, of what kind, where, and once */
+function mayHit(world, missile, caster, ability, entity) {
+	const { effect } = missile;
+	if (!entity.alive || entity.hidden || entity.isResource || entity === caster || missile.hit.has(entity.id)) return false;
+	if (effect.layers && !effect.layers.includes(layerOf(world, entity))) return false;
+	if (effect.kinds && !effect.kinds.includes(entity.def.kind)) return false;
+	if (effect.tags && !hasTag(entity, effect.tags)) return false;
+	if (avoids(world, entity, ability)) return false;
+	if (entity.buffs.length && isUntargetable(world, entity)) return false;
+	const affects = effect.affects ?? "enemies";
+	if (affects === "enemies" && !world.areEnemies(missile.owner, entity.owner)) return false;
+	if (affects === "allies" && !world.areAllies(missile.owner, entity.owner)) return false;
+	return true;
+}
+/**
+* What a missile's effects come to after it sprang on as many times as it has (`bounce.falloff` less each time), and went
+* through as many as it has (`falloff` less for each)
+*/
+function shareOf(missile) {
+	const falloff = missile.effect.bounce?.falloff;
+	let share;
+	if (missile.bounces && falloff) {
+		share = 1;
+		for (let i = 0; i < missile.bounces; i++) share *= Math.max(1 - falloff, 0);
+	}
+	const through = missile.effect.falloff;
+	if (missile.struck && through) {
+		share ??= 1;
+		for (let i = 0; i < missile.struck; i++) share *= Math.max(1 - through, 0);
+	}
+	return share;
+}
+/** Whether a missile that goes through so many (`pierce`) is used up by what it hit last */
+function usedUp(missile) {
+	const { pierce } = missile.effect;
+	return pierce === false || typeof pierce === "number" && (missile.struck ?? 0) > pierce;
+}
+/** Whether counting what a missile went through matters to it (`pierce` a number, `falloff`) */
+var counts = (missile) => typeof missile.effect.pierce === "number" || !!missile.effect.falloff;
+/**
+* What a missile does to one it hits: its effects, as much of them as is left after its springs. False where the game
+* would not let it reach that one (`beforeEffect`)
+*/
+function strike(world, missile, caster, ability, target) {
+	missile.hit.add(target.id);
+	const point = {
+		x: target.pos.x,
+		z: target.pos.z
+	};
+	const context = {
+		world,
+		caster,
+		ability,
+		level: missile.level,
+		target,
+		point,
+		distance: missile.travelled,
+		share: shareOf(missile),
+		held: missile.held
+	};
+	if (!mayReach(context, missile.effect, target, missile)) return false;
+	if (counts(missile)) missile.struck = (missile.struck ?? 0) + 1;
+	if (missile.effect.onWall) missile.last = target.id;
+	land(context, missile.effect.effects);
+	world.events.emit(missileHit, {
+		missile,
+		target
+	});
+	return true;
+}
+/** The nearest a missile may hit within `range` of where it is, the lowest id among those as near */
+function nearestFor(world, missile, caster, ability, range) {
+	let next;
+	let nearest = Infinity;
+	for (const entity of world.spatial.query(missile.x, missile.z, range, crossed)) {
+		if (!mayHit(world, missile, caster, ability, entity)) continue;
+		const gap = distanceToEdge(missile, entity);
+		if (gap > range || gap > nearest || gap === nearest && next && entity.id > next.id) continue;
+		nearest = gap;
+		next = entity;
+	}
+	return next;
+}
+/**
+* What a missile passes through where it is now: each it may hit, once. True when one used it up (`pierce`) or it is
+* gone; `back`: on its way back (`hitsOnReturn`), when nothing uses it up
+*/
+function passThrough(world, missile, caster, ability, back = false) {
+	for (const entity of [...world.spatial.query(missile.x, missile.z, missile.radius, crossed)]) {
+		if (!mayHit(world, missile, caster, ability, entity) || distanceToEdge(missile, entity) > missile.radius) continue;
+		const struck = strike(world, missile, caster, ability, entity);
+		if (gone.has(missile)) return true;
+		if (!back && struck && usedUp(missile)) return true;
+	}
+	return false;
+}
+/** What a missile's split sends off from where it is, the way it flew (`split`) */
+function splitOff(world, missile, caster, ability) {
+	const { split } = missile.effect;
+	if (!split) return;
+	const origin = {
+		x: missile.x,
+		z: missile.z
+	};
+	const point = {
+		x: missile.x + missile.dx,
+		z: missile.z + missile.dz
+	};
+	run({
+		world,
+		caster,
+		ability,
+		level: missile.level,
+		point,
+		origin,
+		heading: atan2(missile.dx, missile.dz),
+		distance: missile.travelled
+	}, split);
+}
+/**
+* Splits a missile where it is now (`EffectFields.split`), as it would once done: what a game's own recast does (Vel'Koz's
+* Plasma Fission). It is gone, its `onEnd` not happening; false for one not in the world, or with no caster or ability left
+*
+* @beta
+*/
+function splitMissile(world, missile) {
+	const caster = world.get(missile.source);
+	const ability = world.registry.abilities.has(missile.ability) ? world.registry.ability(missile.ability) : void 0;
+	if (!caster || !ability || !drop(world, missile)) return false;
+	splitOff(world, missile, caster, ability);
+	return true;
+}
+/**
+* Turns a missile that is steered (`EffectFields.steer`) towards a point, as its owner's `steer` command does: it turns
+* that way as it flies, as fast as its `rate` lets it. False for one that is not steered, or not in the world
+*
+* @beta
+*/
+function steerMissile(world, missile, point) {
+	if (!missile.effect.steer || !world.missiles.includes(missile)) return false;
+	missile.steerTo = {
+		x: point.x,
+		z: point.z
+	};
+	return true;
+}
+/** Turns a steered missile towards where it is steered, at most its rate this round */
+function steer(missile, dt) {
+	const to = missile.steerTo;
+	if (!to) return;
+	const dx = to.x - missile.x;
+	const dz = to.z - missile.z;
+	if (hypot(dx, dz) < .05) return;
+	const now = atan2(missile.dx, missile.dz);
+	let turn = atan2(dx, dz) - now;
+	while (turn > Math.PI) turn -= Math.PI * 2;
+	while (turn < -Math.PI) turn += Math.PI * 2;
+	const most = (missile.effect.steer?.rate ?? Math.PI) * dt;
+	const heading = now + Math.max(-most, Math.min(most, turn));
+	missile.dx = sin(heading);
+	missile.dz = cos(heading);
+}
+/**
+* Whether a missile is at a wall (`onWall`): off the play area, on ground nothing walks, on a cliff above where it set
+* off, or at a building or a tree
+*/
+function atWall(world, missile) {
+	const { terrain } = world;
+	const { x, z } = missile;
+	if (x < 0 || z < 0 || x >= terrain.width || z >= terrain.depth) return true;
+	const cx = Math.floor(x);
+	const cz = Math.floor(z);
+	if (!terrain.inPlay(cx, cz)) return true;
+	const cell = cz * terrain.width + cx;
+	if (terrain.blocked[cell] === 2 || terrain.levels[cell] > (missile.floor ?? 0)) return true;
+	for (const entity of world.spatial.query(x, z, missile.radius, crossed)) if (entity.alive && !entity.hidden && entity.def.kind !== "unit" && distanceToEdge(missile, entity) <= missile.radius) return true;
+	return false;
+}
+/**
+* Where a missile that bounces would be done, it springs on (`EffectFields.bounce`): after the nearest one within its
+* range of where it is that it may hit and has not, the lowest id among those as near. False when it has sprung as many
+* times as it may, or there is nobody to spring on to
+*/
+function springOn(world, missile, caster, ability) {
+	const { bounce, arc } = missile.effect;
+	if (!bounce || missile.bounces >= Math.round(at(bounce.count, missile.level))) return false;
+	const next = nearestFor(world, missile, caster, ability, bounce.range);
+	if (!next) return false;
+	missile.target = next.id;
+	missile.bounces++;
+	missile.leg = 0;
+	missile.left = Infinity;
+	missile.stopped = false;
+	if (arc?.time && arc.time > 0) missile.speed = dist(missile, next.pos) / arc.time;
+	return true;
+}
+/** A missile that comes back (`EffectFields.returns`) turns for the caster where it would be done */
+function turnBack(missile) {
+	if (missile.effect.hitsOnReturn) missile.hit = /* @__PURE__ */ new Set();
+	missile.returning = true;
+	missile.target = 0;
+	missile.left = Infinity;
+	missile.leg = 0;
+	missile.height = 0;
+}
+/** How high a missile's arc carries it, `leg` along a way that has `left` to go: highest halfway */
+var arcHeight = (arc, leg, left) => {
+	if (!arc || !(leg + left > 0) || !Number.isFinite(left)) return 0;
+	const way = leg / (leg + left);
+	return 4 * arc.height * way * (1 - way);
+};
+/** Moves the missiles of abilities along, and lets them do what they do to what they pass through and where they come down */
+function updateMissiles(world, dt) {
+	if (!world.missiles.length) return;
+	const missiles = world.missiles.slice();
+	for (let i = missiles.length - 1; i >= 0; i--) {
+		const missile = missiles[i];
+		if (gone.has(missile)) continue;
+		if (missile.delay > 0) {
+			missile.delay -= dt;
+			missile.prevX = missile.x;
+			missile.prevZ = missile.z;
+			continue;
+		}
+		const caster = world.entities.get(missile.source);
+		const { effect } = missile;
+		const ability = world.registry.abilities.has(missile.ability) ? world.registry.ability(missile.ability) : void 0;
+		missile.prevX = missile.x;
+		missile.prevZ = missile.z;
+		if (missile.returning) {
+			if (!caster?.alive || caster.hidden || !ability) {
+				drop(world, missile);
+				continue;
+			}
+			const gap = dist(missile, caster.pos);
+			const step = missile.speed * dt;
+			if (gap > .01) {
+				missile.dx = (caster.pos.x - missile.x) / gap;
+				missile.dz = (caster.pos.z - missile.z) / gap;
+			}
+			if (gap > step + caster.def.radius * .5) {
+				missile.x += missile.dx * step;
+				missile.z += missile.dz * step;
+				missile.travelled += step;
+				if (effect.hitsOnReturn && effect.effects?.length) passThrough(world, missile, caster, ability, true);
+				continue;
+			}
+			missile.x = caster.pos.x;
+			missile.z = caster.pos.z;
+			missile.travelled += gap;
+			if (effect.onEnd) {
+				const point = {
+					x: caster.pos.x,
+					z: caster.pos.z
+				};
+				land({
+					world,
+					caster,
+					ability,
+					level: missile.level,
+					point,
+					distance: missile.travelled,
+					share: shareOf(missile),
+					held: missile.held
+				}, effect.onEnd);
+			}
+			drop(world, missile);
+			continue;
+		}
+		if (effect.seek && caster && ability) {
+			const sought = missile.target ? world.get(missile.target) : void 0;
+			if (missile.target && (!sought?.alive || sought.hidden || missile.hit.has(missile.target))) missile.target = 0;
+			if (!missile.target) missile.target = nearestFor(world, missile, caster, ability, effect.seek)?.id ?? 0;
+		}
+		if (missile.target) {
+			const target = world.get(missile.target);
+			if (!target || target.hidden || !caster || !ability) {
+				if (effect.returns && caster && ability) turnBack(missile);
+				else drop(world, missile);
+				continue;
+			}
+			const gap = dist(missile, target.pos);
+			const step = missile.speed * dt;
+			if (gap > .01) {
+				missile.dx = (target.pos.x - missile.x) / gap;
+				missile.dz = (target.pos.z - missile.z) / gap;
+			}
+			if (gap <= step + target.def.radius * .5) {
+				missile.x = target.pos.x;
+				missile.z = target.pos.z;
+				missile.travelled += gap;
+				missile.leg += gap;
+				missile.height = 0;
+				strike(world, missile, caster, ability, target);
+				if (gone.has(missile) || springOn(world, missile, caster, ability)) continue;
+				if (effect.returns) turnBack(missile);
+				else {
+					drop(world, missile);
+					splitOff(world, missile, caster, ability);
+				}
+				continue;
+			}
+			missile.x += missile.dx * step;
+			missile.z += missile.dz * step;
+			missile.travelled += step;
+			missile.leg += step;
+			missile.height = arcHeight(effect.arc, missile.leg, gap - step);
+			continue;
+		}
+		if (effect.steer) steer(missile, dt);
+		const step = Math.min(missile.speed * dt, missile.left);
+		missile.x += missile.dx * step;
+		missile.z += missile.dz * step;
+		missile.left -= step;
+		missile.travelled += step;
+		missile.leg += step;
+		missile.height = arcHeight(effect.arc, missile.leg, missile.left);
+		if (!effect.arc) {
+			if (caster && ability && effect.effects?.length && passThrough(world, missile, caster, ability) && !gone.has(missile)) {
+				if (!springOn(world, missile, caster, ability)) {
+					missile.left = 0;
+					missile.stopped = true;
+					splitOff(world, missile, caster, ability);
+				}
+			}
+			if (missile.target || gone.has(missile)) continue;
+			if (effect.onWall && !missile.stopped && caster && ability && atWall(world, missile)) {
+				missile.left = 0;
+				missile.stopped = true;
+				const last = missile.last ? world.get(missile.last) : void 0;
+				const point = {
+					x: missile.x,
+					z: missile.z
+				};
+				const target = last?.alive && !last.hidden ? last : void 0;
+				land({
+					world,
+					caster,
+					ability,
+					level: missile.level,
+					point,
+					target,
+					heading: atan2(missile.dx, missile.dz),
+					distance: missile.travelled
+				}, effect.onWall);
+				if (gone.has(missile)) continue;
+			}
+			if (effect.blocked && !missile.stopped) for (const entity of world.spatial.query(missile.x, missile.z, missile.radius, crossed)) {
+				if (!entity.alive || entity.hidden || entity.def.kind === "unit" || distanceToEdge(missile, entity) > missile.radius) continue;
+				missile.left = 0;
+				missile.stopped = true;
+				break;
+			}
+		}
+		if (missile.left <= 0) {
+			if (effect.arc && caster && ability && effect.effects?.length) {
+				for (const entity of [...world.spatial.query(missile.x, missile.z, missile.radius, crossed)]) {
+					if (mayHit(world, missile, caster, ability, entity) && distanceToEdge(missile, entity) <= missile.radius) strike(world, missile, caster, ability, entity);
+					if (gone.has(missile)) break;
+				}
+				if (gone.has(missile)) continue;
+			}
+			if (!missile.stopped && caster && ability && springOn(world, missile, caster, ability)) continue;
+			if (effect.returns && caster && ability) {
+				turnBack(missile);
+				continue;
+			}
+			if (caster && ability && !missile.stopped) splitOff(world, missile, caster, ability);
+			if (caster && ability && effect.onEnd && !missile.stopped) {
+				const point = {
+					x: missile.x,
+					z: missile.z
+				};
+				land({
+					world,
+					caster,
+					ability,
+					level: missile.level,
+					point,
+					distance: missile.travelled,
+					share: shareOf(missile),
+					held: missile.held
+				}, effect.onEnd);
+			}
+			drop(world, missile);
+		}
+	}
+}
+/** What abilities left behind to happen later, and the ground they go on working on */
+function updateLingering(world, dt) {
+	const { delayed } = world;
+	for (let i = delayed.length - 1; i >= 0; i--) {
+		const entry = delayed[i];
+		entry.left -= dt;
+		if (entry.left > 0) continue;
+		delayed.splice(i, 1);
+		const { caster, ability, level, point, from, heading } = entry;
+		land({
+			world,
+			caster,
+			ability,
+			level,
+			point,
+			...from && { origin: from },
+			...heading !== void 0 && { heading }
+		}, entry.effects, entry.impact);
+	}
+	if (!world.zones.length) return;
+	const zones = world.zones.slice();
+	for (let i = zones.length - 1; i >= 0; i--) {
+		const zone = zones[i];
+		if (!world.zones.includes(zone)) continue;
+		if (zone.follows) {
+			const followed = world.get(zone.follows);
+			if (!followed?.alive || followed.hidden) {
+				endZone(world, zone);
+				continue;
+			}
+			zone.x = followed.pos.x;
+			zone.z = followed.pos.z;
+			zone.from = {
+				x: zone.x,
+				z: zone.z
+			};
+			zone.heading = followed.facing;
+		}
+		const { onEnter, onLeave, edge } = zone.effect;
+		if (onEnter || onLeave || edge) comesAndGoes(world, zone);
+		if (!world.zones.includes(zone)) continue;
+		const context = zoneContext(world, zone);
+		zone.left -= dt;
+		zone.next -= dt;
+		if (zone.left <= 0) {
+			world.zones.splice(world.zones.indexOf(zone), 1);
+			land(context, zone.effect.onEnd);
+		} else if (zone.next <= 0) {
+			zone.next = ZONE_INTERVAL;
+			run(context, zone.effect.effects);
+		}
+	}
+}
+/**
+* Who comes into a zone and goes out of it (`onEnter`, `onLeave`, `edge`): its own area (`radius`, `shape`) as `affects`
+* says, seen to every round. Those inside as it is laid come in, and have not crossed its edge
+*/
+function comesAndGoes(world, zone) {
+	const context = zoneContext(world, zone);
+	const { effect } = zone;
+	const now = effectArea(context, effect) ? candidates(context, effect, "enemies").map((entity) => entity.id) : [];
+	now.sort((a, b) => a - b);
+	const before = zone.inside;
+	zone.inside = now;
+	const was = new Set(before ?? []);
+	const is = new Set(now);
+	const to = (id, effects) => {
+		const entity = world.get(id);
+		if (!effects || !entity?.alive || entity.hidden || !world.zones.includes(zone)) return;
+		run({
+			...context,
+			target: entity,
+			point: {
+				x: entity.pos.x,
+				z: entity.pos.z
+			}
+		}, effects);
+	};
+	for (const id of now) {
+		if (was.has(id)) continue;
+		to(id, effect.onEnter);
+		if (before) to(id, effect.edge);
+	}
+	for (const id of before ?? []) {
+		if (is.has(id)) continue;
+		to(id, effect.onLeave);
+		to(id, effect.edge);
+	}
+}
+/** What was waiting for a pull to end (its order) starts over from where the unit was dragged to */
+function letGo(entity) {
+	const order = entity.orders[0];
+	if (order) order.started = false;
+}
+/** Carries those who rush somewhere towards where they are going. Nothing holds them up, and what it does happens when they arrive */
+function updateDashes(world, dt) {
+	for (const entity of world.index.with(dashing)) {
+		const dash = entity.get(dashing);
+		if (!dash || !entity.alive) continue;
+		const { pulled } = dash;
+		const by = pulled && world.get(pulled.by);
+		let edge = 0;
+		if (pulled?.follows) {
+			if (!by?.alive || by.hidden) {
+				entity.remove(dashing);
+				letGo(entity);
+				continue;
+			}
+			dash.x = by.pos.x;
+			dash.z = by.pos.z;
+			edge = by.def.radius + entity.def.radius;
+		}
+		const gap = dist(entity.pos, dash);
+		const step = dash.speed * dt;
+		if (gap - edge > step) {
+			world.place(entity, {
+				x: entity.pos.x + (dash.x - entity.pos.x) / gap * step,
+				z: entity.pos.z + (dash.z - entity.pos.z) / gap * step
+			});
+			continue;
+		}
+		if (!edge) world.place(entity, dash);
+		else if (gap > edge) world.place(entity, {
+			x: dash.x + (entity.pos.x - dash.x) / gap * edge,
+			z: dash.z + (entity.pos.z - dash.z) / gap * edge
+		});
+		entity.remove(dashing);
+		if (dash.buff) removeBuff(world, entity, dash.buff);
+		if (dash.height) touchDown(world, entity);
+		if (pulled) letGo(entity);
+		if (!world.registry.abilities.has(dash.ability)) continue;
+		const ability = world.registry.ability(dash.ability);
+		const point = {
+			x: entity.pos.x,
+			z: entity.pos.z
+		};
+		const to = dash.target ? world.get(dash.target) : void 0;
+		if (!pulled) land({
+			world,
+			caster: entity,
+			ability,
+			level: dash.level,
+			point,
+			target: to?.alive && !to.hidden ? to : void 0
+		}, dash.effects);
+		else if (by?.alive) land({
+			world,
+			caster: by,
+			ability,
+			level: dash.level,
+			target: entity,
+			point
+		}, dash.effects);
+	}
+}
+/** A missile reaching what it hits, to those who see what it hits */
+var toldMissileHit = replicateEvent(missileHit, "missileHit", ({ missile, target }, view) => view.knows(target) ? {
+	type: "missileHit",
+	missile: missile.id,
+	target: target.id
+} : void 0);
+/** Mana given or taken: its side's alone */
+var toldMana = replicateEvent(manaChanged, "mana", ({ entity, amount, ability }, view) => view.isAlly(entity.owner) ? {
+	type: "mana",
+	id: entity.id,
+	amount,
+	ability
+} : void 0);
+/** The missiles of abilities in flight the player is told of: their side's, and those where they see (`Snapshot.missiles`); none to a computer */
+var missilesPart = snapshotField("missiles", (view) => {
+	const missiles = [];
+	if (view.forComputer) return missiles;
+	const { world } = view;
+	for (const m of world.missiles) {
+		if (!view.isAlly(m.owner) && !view.sees(m.x, m.z)) continue;
+		const source = world.get(m.source);
+		missiles.push({
+			id: m.id,
+			ability: m.ability,
+			level: m.level,
+			source: source && view.knows(source) ? source.id : void 0,
+			x: m.x,
+			z: m.z,
+			radius: m.radius,
+			heading: atan2(m.dx, m.dz),
+			forming: m.delay > 0 ? 1 - m.delay / m.forms : void 0,
+			progress: Number.isFinite(m.left) ? m.travelled / (m.travelled + m.left || 1) : void 0,
+			arc: m.height || void 0,
+			returning: m.returning || void 0,
+			effect: effectIndexOf(world, m.ability, m.effect),
+			steered: m.effect.steer && view.isAlly(m.owner) || void 0
+		});
+	}
+	return missiles;
+});
+//#endregion
+export { defineEffect, effectFilter, effectTargets, endZone, isCharged, mayReach, missilesPart, removeMissile, splitMissile, startDash, steerMissile, toldMana, toldMissileHit, updateDashes, updateLingering, updateMissiles, zoneContext };
+
+//# sourceMappingURL=effects.js.map