@v12-engine/engine 0.1.0 → 0.4.0

package/dist/abilities/effects/missile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"missile.js","names":[],"sources":["../../../src/abilities/effects/missile.ts"],"sourcesContent":["/**\n * Missiles: the engine's effect that sends what flies (`EffectTypes.missile`), shot or thrown in an arc; what they do\n * on the way, and where they spring on to, is `updateMissiles`'\n */\nimport { missileSpawned } from '#engine/engineEvents'\nimport { at, type EffectOf } from '#engine/defs'\nimport { dist } from '#engine/math'\nimport { atan2, cos, hypot, sin } from '#engine/exactMath'\nimport type { Missile } from '#engine/world'\nimport { defineEffect, type EffectContext } from '../effects'\nimport { effectOrigin } from '../land'\nimport { valueOf } from '../amounts'\n\n/**\n * Sends the missiles of a missile effect (`EffectTypes.missile`) off, as the engine's `missile` effect does, and hands\n * them back: what a game's own effect does that wraps a missile (and keeps it, to steer it, or take it out with\n * `removeMissile`). They go off from the context's `origin` (a ball, a shadow) when it has one, the caster's place\n * otherwise, towards its `point` (its `target`, homing); they are the caster's, and what they hit is in its name\n *\n * @beta\n */\nexport function launchMissile(context: EffectContext, effect: EffectOf<'missile'>): Missile[] {\n\tconst { world, caster, ability, level, point, target } = context\n\tconst from = effectOrigin(context)\n\tconst aim = effect.homing && target ? target.pos : point\n\tconst dx = aim.x - from.x\n\tconst dz = aim.z - from.z\n\tconst length = hypot(dx, dz)\n\t// aimed at its own feet: the way it looks then\n\tconst heading = length > 0.01 ? atan2(dx, dz) : caster.facing\n\tconst count = Math.max(Math.round(at(effect.count, level, 1)), 1)\n\tconst range = at(effect.distance, level, effect.toPoint ? Infinity : 10)\n\tconst hit = new Set<number>()\n\tconst homing = effect.homing && target\n\tconst left = homing ? Infinity : effect.toPoint ? Math.min(length, range) : range\n\t// thrown in a time of its own: as fast as it takes to come down then, at its target or at the end of its way\n\tconst time = effect.arc?.time\n\tconst way = homing ? dist(from, target.pos) : left\n\tconst speed = time && time > 0 && Number.isFinite(way) ? way / time : (effect.speed ?? 10)\n\tconst sent: Missile[] = []\n\tfor (let i = 0; i < count; i++) {\n\t\tconst angle = heading + (count > 1 ? (effect.spread ?? 0) * (i / (count - 1) - 0.5) : 0)\n\t\tconst missile: Missile = {\n\t\t\tid: world.newId(),\n\t\t\towner: caster.owner,\n\t\t\tsource: caster.id,\n\t\t\tability: ability.id,\n\t\t\tlevel,\n\t\t\tx: from.x,\n\t\t\tz: from.z,\n\t\t\tprevX: from.x,\n\t\t\tprevZ: from.z,\n\t\t\tdx: sin(angle),\n\t\t\tdz: cos(angle),\n\t\t\tspeed,\n\t\t\tleft,\n\t\t\tdelay: at(effect.delay, level),\n\t\t\tforms: at(effect.delay, level),\n\t\t\tradius: valueOf(context, effect.radius, undefined, 1),\n\t\t\teffect,\n\t\t\thit,\n\t\t\ttarget: homing ? target.id : 0,\n\t\t\ttravelled: 0,\n\t\t\tleg: 0,\n\t\t\theight: 0,\n\t\t\tbounces: 0,\n\t\t\tstopped: false,\n\t\t\t// what a cliff is to one that stops at walls: higher than the ground it set off from\n\t\t\t...(effect.onWall && { floor: world.terrain.levelAt(from.x, from.z) }),\n\t\t\t// how full what sent it was held (AB15): what it lands is grown by it\n\t\t\t...(context.held !== undefined && { held: context.held })\n\t\t}\n\t\tworld.missiles.push(missile)\n\t\tworld.events.emit(missileSpawned, missile)\n\t\tsent.push(missile)\n\t}\n\treturn sent\n}\n\nexport const missileEffect = defineEffect({\n\ttype: 'missile',\n\trun: (context, effect) => void launchMissile(context, effect),\n\tfields: [\n\t\t'speed',\n\t\t'distance',\n\t\t'count',\n\t\t'spread',\n\t\t'homing',\n\t\t'toPoint',\n\t\t'delay',\n\t\t'sight',\n\t\t'blocked',\n\t\t'pierce',\n\t\t'falloff',\n\t\t'arc',\n\t\t'bounce',\n\t\t'returns',\n\t\t'hitsOnReturn',\n\t\t'seek',\n\t\t'steer',\n\t\t'effects',\n\t\t'onEnd',\n\t\t'onWall',\n\t\t'split'\n\t]\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,cAAc,SAAwB,QAAwC;CAC7F,MAAM,EAAE,OAAO,QAAQ,SAAS,OAAO,OAAO,WAAW;CACzD,MAAM,OAAO,aAAa,OAAO;CACjC,MAAM,MAAM,OAAO,UAAU,SAAS,OAAO,MAAM;CACnD,MAAM,KAAK,IAAI,IAAI,KAAK;CACxB,MAAM,KAAK,IAAI,IAAI,KAAK;CACxB,MAAM,SAAS,MAAM,IAAI,EAAE;CAE3B,MAAM,UAAU,SAAS,MAAO,MAAM,IAAI,EAAE,IAAI,OAAO;CACvD,MAAM,QAAQ,KAAK,IAAI,KAAK,MAAM,GAAG,OAAO,OAAO,OAAO,CAAC,CAAC,GAAG,CAAC;CAChE,MAAM,QAAQ,GAAG,OAAO,UAAU,OAAO,OAAO,UAAU,WAAW,EAAE;CACvE,MAAM,sBAAM,IAAI,IAAY;CAC5B,MAAM,SAAS,OAAO,UAAU;CAChC,MAAM,OAAO,SAAS,WAAW,OAAO,UAAU,KAAK,IAAI,QAAQ,KAAK,IAAI;CAE5E,MAAM,OAAO,OAAO,KAAK;CACzB,MAAM,MAAM,SAAS,KAAK,MAAM,OAAO,GAAG,IAAI;CAC9C,MAAM,QAAQ,QAAQ,OAAO,KAAK,OAAO,SAAS,GAAG,IAAI,MAAM,OAAQ,OAAO,SAAS;CACvF,MAAM,OAAkB,CAAC;CACzB,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;EAC/B,MAAM,QAAQ,WAAW,QAAQ,KAAK,OAAO,UAAU,MAAM,KAAK,QAAQ,KAAK,MAAO;EACtF,MAAM,UAAmB;GACxB,IAAI,MAAM,MAAM;GAChB,OAAO,OAAO;GACd,QAAQ,OAAO;GACf,SAAS,QAAQ;GACjB;GACA,GAAG,KAAK;GACR,GAAG,KAAK;GACR,OAAO,KAAK;GACZ,OAAO,KAAK;GACZ,IAAI,IAAI,KAAK;GACb,IAAI,IAAI,KAAK;GACb;GACA;GACA,OAAO,GAAG,OAAO,OAAO,KAAK;GAC7B,OAAO,GAAG,OAAO,OAAO,KAAK;GAC7B,QAAQ,QAAQ,SAAS,OAAO,QAAQ,KAAA,GAAW,CAAC;GACpD;GACA;GACA,QAAQ,SAAS,OAAO,KAAK;GAC7B,WAAW;GACX,KAAK;GACL,QAAQ;GACR,SAAS;GACT,SAAS;GAET,GAAI,OAAO,UAAU,EAAE,OAAO,MAAM,QAAQ,QAAQ,KAAK,GAAG,KAAK,CAAC,EAAE;GAEpE,GAAI,QAAQ,SAAS,KAAA,KAAa,EAAE,MAAM,QAAQ,KAAK;EACxD;EACA,MAAM,SAAS,KAAK,OAAO;EAC3B,MAAM,OAAO,KAAK,gBAAgB,OAAO;EACzC,KAAK,KAAK,OAAO;CAClB;CACA,OAAO;AACR;AAEA,IAAa,gBAAgB,aAAa;CACzC,MAAM;CACN,MAAM,SAAS,WAAW,KAAK,cAAc,SAAS,MAAM;CAC5D,QAAQ;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD;AACD,CAAC"}

package/dist/abilities/effects/morph.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Turns the caster into `into` where it stands (`takeForm`), for `duration` seconds or until cast again (`toggle`);
+ * cast again in the form, it turns it back where `back` has `ability`, and starts its time over where it has not
+ */
+export declare const morphEffect: import("../effects").EffectType<"morph">;

package/dist/abilities/effects/morph.js

@@ -0,0 +1,43 @@
+import { form } from "../../formState.js";
+import { valueOf } from "../amounts.js";
+import { defineEffect } from "../effects.js";
+import { leaveForm, takeForm } from "../../forms.js";
+//#region src/abilities/effects/morph.ts
+/**
+* Turns the caster into `into` where it stands (`takeForm`), for `duration` seconds or until cast again (`toggle`);
+* cast again in the form, it turns it back where `back` has `ability`, and starts its time over where it has not
+*/
+var morphEffect = defineEffect({
+	type: "morph",
+	run: (context, effect) => {
+		const { world, caster, ability } = context;
+		if (!effect.into || caster.def.kind !== "unit" || !caster.alive) return;
+		const back = effect.back ?? (effect.toggle ? [
+			"ability",
+			"time",
+			"death"
+		] : ["time", "death"]);
+		const duration = effect.duration === void 0 ? void 0 : valueOf(context, effect.duration);
+		const current = caster.get(form);
+		if (current?.by === ability.id) {
+			if (current.back.includes("ability")) leaveForm(world, caster, "ability");
+			else if (duration !== void 0 && back.includes("time")) current.until = world.time + duration;
+			return;
+		}
+		takeForm(world, caster, effect.into, {
+			duration,
+			back,
+			by: ability.id
+		});
+	},
+	fields: [
+		"into",
+		"duration",
+		"toggle",
+		"back"
+	]
+});
+//#endregion
+export { morphEffect };
+
+//# sourceMappingURL=morph.js.map

package/dist/abilities/effects/morph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"morph.js","names":[],"sources":["../../../src/abilities/effects/morph.ts"],"sourcesContent":["/**\n * The engine's effect that turns a hero into one of its forms and back (`EffectTypes.morph`, E2E-PLAN LB2)\n */\nimport type { MorphBack } from '#engine/defs'\nimport { leaveForm, takeForm } from '#engine/forms'\nimport { form } from '#engine/formState'\nimport { valueOf } from '../amounts'\nimport { defineEffect } from '../effects'\n\n/**\n * Turns the caster into `into` where it stands (`takeForm`), for `duration` seconds or until cast again (`toggle`);\n * cast again in the form, it turns it back where `back` has `ability`, and starts its time over where it has not\n */\nexport const morphEffect = defineEffect({ type: 'morph', run: (context, effect) => {\n\t\tconst { world, caster, ability } = context\n\t\tif (!effect.into || caster.def.kind !== 'unit' || !caster.alive) return\n\t\tconst back: MorphBack[] = effect.back ?? (effect.toggle ? ['ability', 'time', 'death'] : ['time', 'death'])\n\t\tconst duration = effect.duration === undefined ? undefined : valueOf(context, effect.duration)\n\t\tconst current = caster.get(form)\n\t\tif (current?.by === ability.id) {\n\t\t\tif (current.back.includes('ability')) leaveForm(world, caster, 'ability')\n\t\t\telse if (duration !== undefined && back.includes('time')) current.until = world.time + duration\n\t\t\treturn\n\t\t}\n\t\ttakeForm(world, caster, effect.into, { duration, back, by: ability.id })\n\t}, fields: ['into', 'duration', 'toggle', 'back'] })\n"],"mappings":";;;;;;;;;AAaA,IAAa,cAAc,aAAa;CAAE,MAAM;CAAS,MAAM,SAAS,WAAW;EACjF,MAAM,EAAE,OAAO,QAAQ,YAAY;EACnC,IAAI,CAAC,OAAO,QAAQ,OAAO,IAAI,SAAS,UAAU,CAAC,OAAO,OAAO;EACjE,MAAM,OAAoB,OAAO,SAAS,OAAO,SAAS;GAAC;GAAW;GAAQ;EAAO,IAAI,CAAC,QAAQ,OAAO;EACzG,MAAM,WAAW,OAAO,aAAa,KAAA,IAAY,KAAA,IAAY,QAAQ,SAAS,OAAO,QAAQ;EAC7F,MAAM,UAAU,OAAO,IAAI,IAAI;EAC/B,IAAI,SAAS,OAAO,QAAQ,IAAI;GAC/B,IAAI,QAAQ,KAAK,SAAS,SAAS,GAAG,UAAU,OAAO,QAAQ,SAAS;QACnE,IAAI,aAAa,KAAA,KAAa,KAAK,SAAS,MAAM,GAAG,QAAQ,QAAQ,MAAM,OAAO;GACvF;EACD;EACA,SAAS,OAAO,QAAQ,OAAO,MAAM;GAAE;GAAU;GAAM,IAAI,QAAQ;EAAG,CAAC;CACxE;CAAG,QAAQ;EAAC;EAAQ;EAAY;EAAU;CAAM;AAAE,CAAC"}

package/dist/abilities/effects/moves.d.ts

@@ -1,11 +1,23 @@
+import type { AbilityDef, EffectDef } from '#engine/defs';
+/** Which effect of its ability sends a rush, for the screen to draw it by (`Dash.effect`) */
+export declare function screenOf(ability: AbilityDef, effect: EffectDef): {
+    effect?: number;
+};
 /** The caster is somewhere else at once: towards where it was aimed, as far as `distance` lets it */
-export declare const blinkEffect: import("../effects").EffectKind<"blink">;
+export declare const blinkEffect: import("../effects").EffectType<"blink">;
 /**
  * The caster is somewhere else at once, however far (`to`): its side's home (`homeOf`, a recall), where it was aimed
  * (`point`, when left out), or by its target. Nothing where there is no such place
  */
-export declare const teleportEffect: import("../effects").EffectKind<"teleport">;
+export declare const teleportEffect: import("../effects").EffectType<"teleport">;
 /** The caster rushes to the spot, through whatever is in the way. `effects` happen around where it ends */
-export declare const dashEffect: import("../effects").EffectKind<"dash">;
+export declare const dashEffect: import("../effects").EffectType<"dash">;
 /** Throws the targets `distance` away from the caster. Nothing stops them on the way, and who is rushing somewhere is not thrown */
-export declare const knockbackEffect: import("../effects").EffectKind<"knockback">;
+export declare const knockbackEffect: import("../effects").EffectType<"knockback">;
+/**
+ * Drags the targets to the caster's edge, after it as it moves, or to where the effect landed (`toPoint`), in `seconds`
+ * at the speed that takes from where they are; `effects` happen to each as it arrives, in the caster's name. Meanwhile
+ * it is on a rush (`dashing`, `pulled`): its orders wait and start over after, and it neither casts, nor blinks, nor
+ * dashes, nor is thrown. Who is rushing somewhere already, and structures, are not pulled
+ */
+export declare const pullEffect: import("../effects").EffectType<"pull">;

package/dist/abilities/effects/moves.js

@@ -0,0 +1,212 @@
+import { atan2, hypot } from "../../exactMath.js";
+import { dist } from "../../math.js";
+import { at } from "../../defs.js";
+import { moving } from "../../entity.js";
+import { effectIndex } from "../effectIndex.js";
+import { applyBuff, isGrounded, isUnstoppable } from "../buffs.js";
+import { halt } from "../../systems/movement.js";
+import { cancelSwing } from "../../systems/combat.js";
+import { dashing } from "../../dashing.js";
+import { defineEffect, effectTargets, startDash } from "../effects.js";
+import { homeOf } from "../../home.js";
+//#region src/abilities/effects/moves.ts
+/**
+* Moves: the engine's effects that put the caster elsewhere (`EffectTypes.blink`, `teleport`), rush it there (`dash`),
+* throw what it hits (`knockback`) or drag it in (`pull`). Who is being dragged moves itself nowhere
+*/
+/** Which effect of its ability sends a rush, for the screen to draw it by (`Dash.effect`) */
+function screenOf(ability, effect) {
+	const index = effectIndex(ability, effect);
+	return index === void 0 ? {} : { effect: index };
+}
+/** How finely the way of a leap is looked over for ground that stands too high */
+var LEAP_STEP = .5;
+/** The last spot on the way from one place to another before the ground rises above `top` */
+function beforeWall(world, from, to, top) {
+	const steps = Math.ceil(dist(from, to) / LEAP_STEP);
+	let last = {
+		x: from.x,
+		z: from.z
+	};
+	for (let i = 1; i <= steps; i++) {
+		const t = i / steps;
+		const point = {
+			x: from.x + (to.x - from.x) * t,
+			z: from.z + (to.z - from.z) * t
+		};
+		if (world.terrain.heightAt(point.x, point.z) > top) return last;
+		last = point;
+	}
+	return last;
+}
+/** Being dragged by a `pull`: it goes nowhere of its own, at once or on a rush */
+var pulled = (entity) => !!entity.get(dashing)?.pulled;
+/** Kept from rushing or jumping of its own (`BuffDef.grounded`), or dragged */
+var held = (world, entity) => pulled(entity) || entity.buffs.length > 0 && isGrounded(world, entity);
+/** Nothing moves it that it does not want to (`BuffDef.unstoppable`) */
+var unmoved = (world, entity) => entity.buffs.length > 0 && isUnstoppable(world, entity);
+/** The caster is somewhere else at once: towards where it was aimed, as far as `distance` lets it */
+var blinkEffect = defineEffect({
+	type: "blink",
+	run: (context, effect) => {
+		const { world, caster, point, level } = context;
+		if (held(world, caster)) return;
+		const dx = point.x - caster.pos.x;
+		const dz = point.z - caster.pos.z;
+		const length = hypot(dx, dz);
+		if (length < .01) return;
+		const step = Math.min(length, at(effect.distance, level, 5));
+		const aim = {
+			x: caster.pos.x + dx / length * step,
+			z: caster.pos.z + dz / length * step
+		};
+		const spot = (caster.flying ? world.air : world.nav).closestPoint(aim, 3) ?? caster.pos;
+		world.place(caster, spot);
+		caster.prevPos.x = spot.x;
+		caster.prevPos.z = spot.z;
+		point.x = spot.x;
+		point.z = spot.z;
+	},
+	fields: ["distance"]
+});
+/**
+* The caster is somewhere else at once, however far (`to`): its side's home (`homeOf`, a recall), where it was aimed
+* (`point`, when left out), or by its target. Nothing where there is no such place
+*/
+var teleportEffect = defineEffect({
+	type: "teleport",
+	run: (context, effect) => {
+		const { world, caster, point, target } = context;
+		if (pulled(caster)) return;
+		const to = effect.to ?? "point";
+		const aim = to === "home" ? homeOf(world, caster.owner, caster.pos) : to === "target" ? target?.pos : point;
+		if (!aim) return;
+		const spot = (caster.flying ? world.air : world.nav).closestPoint(aim, 6) ?? aim;
+		world.place(caster, spot);
+		caster.prevPos.x = spot.x;
+		caster.prevPos.z = spot.z;
+		point.x = spot.x;
+		point.z = spot.z;
+	},
+	fields: ["to"]
+});
+/** The caster rushes to the spot, through whatever is in the way. `effects` happen around where it ends */
+var dashEffect = defineEffect({
+	type: "dash",
+	run: (context, effect) => {
+		const { world, caster, ability, level, point } = context;
+		if (held(world, caster)) return;
+		const gap = dist(caster.pos, point);
+		const far = Math.min(gap, at(effect.distance, level, Infinity));
+		let aim = gap > far ? {
+			x: caster.pos.x + (point.x - caster.pos.x) / gap * far,
+			z: caster.pos.z + (point.z - caster.pos.z) / gap * far
+		} : point;
+		const nav = caster.flying ? world.air : world.nav;
+		let spot = nav.closestPoint(aim, 4) ?? aim;
+		if (effect.leap && effect.climb !== void 0) {
+			const top = world.terrain.heightAt(caster.pos.x, caster.pos.z) + effect.climb;
+			aim = beforeWall(world, caster.pos, aim, top);
+			spot = nav.closestPoint(aim, 2) ?? aim;
+			if (world.terrain.heightAt(spot.x, spot.z) > top) spot = aim;
+		}
+		if (dist(caster.pos, spot) > .05) caster.facing = atan2(spot.x - caster.pos.x, spot.z - caster.pos.z);
+		startDash(world, caster, {
+			x: spot.x,
+			z: spot.z,
+			speed: effect.speed ?? 18,
+			ability: ability.id,
+			level,
+			...screenOf(ability, effect),
+			effects: effect.effects ?? [],
+			height: effect.leap,
+			buff: effect.buff
+		});
+		if (effect.buff) applyBuff(world, caster, effect.buff, Infinity, caster, level);
+	},
+	fields: [
+		"distance",
+		"leap",
+		"climb",
+		"speed",
+		"effects",
+		"buff"
+	]
+});
+/** Throws the targets `distance` away from the caster. Nothing stops them on the way, and who is rushing somewhere is not thrown */
+var knockbackEffect = defineEffect({
+	type: "knockback",
+	run: (context, effect) => {
+		const { world, caster, ability, level } = context;
+		const far = at(effect.distance, level, 4);
+		for (const entity of effectTargets(context, effect, "enemies")) {
+			if (!entity.isUnit || !entity.get(moving) || entity.get(dashing) || unmoved(world, entity)) continue;
+			const dx = entity.pos.x - caster.pos.x;
+			const dz = entity.pos.z - caster.pos.z;
+			const gap = hypot(dx, dz) || 1;
+			const to = {
+				x: entity.pos.x + dx / gap * far,
+				z: entity.pos.z + dz / gap * far
+			};
+			const spot = (entity.flying ? world.air : world.nav).closestPoint(to, 4) ?? to;
+			startDash(world, entity, {
+				x: spot.x,
+				z: spot.z,
+				speed: effect.speed ?? 22,
+				ability: ability.id,
+				level,
+				...screenOf(ability, effect),
+				effects: [],
+				height: effect.leap
+			});
+		}
+	},
+	fields: [
+		"distance",
+		"speed",
+		"leap"
+	]
+});
+/**
+* Drags the targets to the caster's edge, after it as it moves, or to where the effect landed (`toPoint`), in `seconds`
+* at the speed that takes from where they are; `effects` happen to each as it arrives, in the caster's name. Meanwhile
+* it is on a rush (`dashing`, `pulled`): its orders wait and start over after, and it neither casts, nor blinks, nor
+* dashes, nor is thrown. Who is rushing somewhere already, and structures, are not pulled
+*/
+var pullEffect = defineEffect({
+	type: "pull",
+	run: (context, effect) => {
+		const { world, caster, ability, level, point } = context;
+		const seconds = Math.max(at(effect.seconds, level, .5), .05);
+		const follows = !effect.toPoint;
+		for (const entity of effectTargets(context, effect, "enemies")) {
+			if (entity === caster || !entity.isUnit || !entity.get(moving) || entity.get(dashing) || unmoved(world, entity)) continue;
+			const to = follows ? caster.pos : point;
+			const way = Math.max(dist(entity.pos, to) - (follows ? caster.def.radius + entity.def.radius : 0), 0);
+			halt(world, entity);
+			cancelSwing(world, entity);
+			startDash(world, entity, {
+				x: to.x,
+				z: to.z,
+				speed: Math.max(way / seconds, .01),
+				ability: ability.id,
+				level,
+				...screenOf(ability, effect),
+				effects: effect.effects ?? [],
+				pulled: {
+					by: caster.id,
+					follows
+				}
+			});
+		}
+	},
+	fields: [
+		"seconds",
+		"toPoint",
+		"effects"
+	]
+});
+//#endregion
+export { blinkEffect, dashEffect, knockbackEffect, pullEffect, screenOf, teleportEffect };
+
+//# sourceMappingURL=moves.js.map

package/dist/abilities/effects/moves.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moves.js","names":[],"sources":["../../../src/abilities/effects/moves.ts"],"sourcesContent":["/**\n * Moves: the engine's effects that put the caster elsewhere (`EffectTypes.blink`, `teleport`), rush it there (`dash`),\n * throw what it hits (`knockback`) or drag it in (`pull`). Who is being dragged moves itself nowhere\n */\nimport { at } from '#engine/defs'\nimport { dashing } from '#engine/dashing'\nimport { moving } from '#engine/entity'\nimport { atan2, hypot } from '#engine/exactMath'\nimport { homeOf } from '#engine/home'\nimport { dist, type Vec2 } from '#engine/math'\nimport { cancelSwing } from '#engine/systems/combat'\nimport { halt } from '#engine/systems/movement'\nimport type { Entity } from '#engine/entity'\nimport type { World } from '#engine/world'\nimport { applyBuff, isGrounded, isUnstoppable } from '../buffs'\nimport { defineEffect, effectTargets, startDash } from '../effects'\nimport { effectIndex } from '../effectIndex'\nimport type { AbilityDef, EffectDef } from '#engine/defs'\n\n/** Which effect of its ability sends a rush, for the screen to draw it by (`Dash.effect`) */\nexport function screenOf(ability: AbilityDef, effect: EffectDef): { effect?: number } {\n\tconst index = effectIndex(ability, effect)\n\treturn index === undefined ? {} : { effect: index }\n}\n\n/** How finely the way of a leap is looked over for ground that stands too high */\nconst LEAP_STEP = 0.5\n\n/** The last spot on the way from one place to another before the ground rises above `top` */\nfunction beforeWall(world: World, from: Vec2, to: Vec2, top: number): Vec2 {\n\tconst steps = Math.ceil(dist(from, to) / LEAP_STEP)\n\tlet last = { x: from.x, z: from.z }\n\tfor (let i = 1; i <= steps; i++) {\n\t\tconst t = i / steps\n\t\tconst point = { x: from.x + (to.x - from.x) * t, z: from.z + (to.z - from.z) * t }\n\t\tif (world.terrain.heightAt(point.x, point.z) > top) return last\n\t\tlast = point\n\t}\n\treturn last\n}\n\n/** Being dragged by a `pull`: it goes nowhere of its own, at once or on a rush */\nconst pulled = (entity: Entity): boolean => !!entity.get(dashing)?.pulled\n\n/** Kept from rushing or jumping of its own (`BuffDef.grounded`), or dragged */\nconst held = (world: World, entity: Entity): boolean => pulled(entity) || (entity.buffs.length > 0 && isGrounded(world, entity))\n\n/** Nothing moves it that it does not want to (`BuffDef.unstoppable`) */\nconst unmoved = (world: World, entity: Entity): boolean => entity.buffs.length > 0 && isUnstoppable(world, entity)\n\n/** The caster is somewhere else at once: towards where it was aimed, as far as `distance` lets it */\nexport const blinkEffect = defineEffect({ type: 'blink', run: (context, effect) => {\n\t\tconst { world, caster, point, level } = context\n\t\tif (held(world, caster)) return\n\t\tconst dx = point.x - caster.pos.x\n\t\tconst dz = point.z - caster.pos.z\n\t\tconst length = hypot(dx, dz)\n\t\tif (length < 0.01) return\n\t\tconst step = Math.min(length, at(effect.distance, level, 5))\n\t\tconst aim = { x: caster.pos.x + (dx / length) * step, z: caster.pos.z + (dz / length) * step }\n\t\tconst spot = (caster.flying ? world.air : world.nav).closestPoint(aim, 3) ?? caster.pos\n\t\tworld.place(caster, spot)\n\t\tcaster.prevPos.x = spot.x\n\t\tcaster.prevPos.z = spot.z\n\t\t// where it went is where the ability landed, for whoever draws it\n\t\tpoint.x = spot.x\n\t\tpoint.z = spot.z\n\t}, fields: ['distance'] })\n\n/**\n * The caster is somewhere else at once, however far (`to`): its side's home (`homeOf`, a recall), where it was aimed\n * (`point`, when left out), or by its target. Nothing where there is no such place\n */\nexport const teleportEffect = defineEffect({ type: 'teleport', run: (context, effect) => {\n\t\tconst { world, caster, point, target } = context\n\t\tif (pulled(caster)) return\n\t\tconst to = effect.to ?? 'point'\n\t\tconst aim = to === 'home' ? homeOf(world, caster.owner, caster.pos) : to === 'target' ? target?.pos : point\n\t\tif (!aim) return\n\t\tconst spot = (caster.flying ? world.air : world.nav).closestPoint(aim, 6) ?? aim\n\t\tworld.place(caster, spot)\n\t\tcaster.prevPos.x = spot.x\n\t\tcaster.prevPos.z = spot.z\n\t\tpoint.x = spot.x\n\t\tpoint.z = spot.z\n\t}, fields: ['to'] })\n\n/** The caster rushes to the spot, through whatever is in the way. `effects` happen around where it ends */\nexport const dashEffect = defineEffect({ type: 'dash', run: (context, effect) => {\n\t\tconst { world, caster, ability, level, point } = context\n\t\tif (held(world, caster)) return\n\t\t// no farther than `distance`, towards where it was aimed\n\t\tconst gap = dist(caster.pos, point)\n\t\tconst far = Math.min(gap, at(effect.distance, level, Infinity))\n\t\tlet aim =\n\t\t\tgap > far ? { x: caster.pos.x + ((point.x - caster.pos.x) / gap) * far, z: caster.pos.z + ((point.z - caster.pos.z) / gap) * far } : point\n\t\tconst nav = caster.flying ? world.air : world.nav\n\t\tlet spot = nav.closestPoint(aim, 4) ?? aim\n\t\tif (effect.leap && effect.climb !== undefined) {\n\t\t\t// a wall too high to get over: down in front of it, and not on top of it by way of the nearest place to stand\n\t\t\tconst top = world.terrain.heightAt(caster.pos.x, caster.pos.z) + effect.climb\n\t\t\taim = beforeWall(world, caster.pos, aim, top)\n\t\t\tspot = nav.closestPoint(aim, 2) ?? aim\n\t\t\tif (world.terrain.heightAt(spot.x, spot.z) > top) spot = aim\n\t\t}\n\t\tif (dist(caster.pos, spot) > 0.05) caster.facing = atan2(spot.x - caster.pos.x, spot.z - caster.pos.z)\n\t\tstartDash(world, caster, {\n\t\t\tx: spot.x,\n\t\t\tz: spot.z,\n\t\t\tspeed: effect.speed ?? 18,\n\t\t\tability: ability.id,\n\t\t\tlevel,\n\t\t\t...screenOf(ability, effect),\n\t\t\teffects: effect.effects ?? [],\n\t\t\theight: effect.leap,\n\t\t\tbuff: effect.buff\n\t\t})\n\t\t// what it is while it is on its way, like out of reach of the ground\n\t\tif (effect.buff) applyBuff(world, caster, effect.buff, Infinity, caster, level)\n\t}, fields: ['distance', 'leap', 'climb', 'speed', 'effects', 'buff'] })\n\n/** Throws the targets `distance` away from the caster. Nothing stops them on the way, and who is rushing somewhere is not thrown */\nexport const knockbackEffect = defineEffect({ type: 'knockback', run: (context, effect) => {\n\t\tconst { world, caster, ability, level } = context\n\t\tconst far = at(effect.distance, level, 4)\n\t\tfor (const entity of effectTargets(context, effect, 'enemies')) {\n\t\t\tif (!entity.isUnit || !entity.get(moving) || entity.get(dashing) || unmoved(world, entity)) continue\n\t\t\tconst dx = entity.pos.x - caster.pos.x\n\t\t\tconst dz = entity.pos.z - caster.pos.z\n\t\t\tconst gap = hypot(dx, dz) || 1\n\t\t\tconst to = { x: entity.pos.x + (dx / gap) * far, z: entity.pos.z + (dz / gap) * far }\n\t\t\tconst spot = (entity.flying ? world.air : world.nav).closestPoint(to, 4) ?? to\n\t\t\tstartDash(world, entity, {\n\t\t\t\tx: spot.x,\n\t\t\t\tz: spot.z,\n\t\t\t\tspeed: effect.speed ?? 22,\n\t\t\t\tability: ability.id,\n\t\t\t\tlevel,\n\t\t\t\t...screenOf(ability, effect),\n\t\t\t\teffects: [],\n\t\t\t\theight: effect.leap\n\t\t\t})\n\t\t}\n\t}, fields: ['distance', 'speed', 'leap'] })\n\n/**\n * Drags the targets to the caster's edge, after it as it moves, or to where the effect landed (`toPoint`), in `seconds`\n * at the speed that takes from where they are; `effects` happen to each as it arrives, in the caster's name. Meanwhile\n * it is on a rush (`dashing`, `pulled`): its orders wait and start over after, and it neither casts, nor blinks, nor\n * dashes, nor is thrown. Who is rushing somewhere already, and structures, are not pulled\n */\nexport const pullEffect = defineEffect({ type: 'pull', run: (context, effect) => {\n\t\tconst { world, caster, ability, level, point } = context\n\t\tconst seconds = Math.max(at(effect.seconds, level, 0.5), 0.05)\n\t\tconst follows = !effect.toPoint\n\t\tfor (const entity of effectTargets(context, effect, 'enemies')) {\n\t\t\tif (entity === caster || !entity.isUnit || !entity.get(moving) || entity.get(dashing) || unmoved(world, entity)) continue\n\t\t\tconst to = follows ? caster.pos : point\n\t\t\tconst way = Math.max(dist(entity.pos, to) - (follows ? caster.def.radius + entity.def.radius : 0), 0)\n\t\t\t// what it was doing waits for the end of the drag, its swing broken off\n\t\t\thalt(world, entity)\n\t\t\tcancelSwing(world, entity)\n\t\t\tstartDash(world, entity, {\n\t\t\t\tx: to.x,\n\t\t\t\tz: to.z,\n\t\t\t\tspeed: Math.max(way / seconds, 0.01),\n\t\t\t\tability: ability.id,\n\t\t\t\tlevel,\n\t\t\t\t...screenOf(ability, effect),\n\t\t\t\teffects: effect.effects ?? [],\n\t\t\t\tpulled: { by: caster.id, follows }\n\t\t\t})\n\t\t}\n\t}, fields: ['seconds', 'toPoint', 'effects'] })\n"],"mappings":"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"}

package/dist/abilities/effects/passives.d.ts

@@ -1,15 +1,25 @@
-/** `onHit` is about attacks, not about the moment of casting: see the function of that name */
-export declare const onHitEffect: import("../effects").EffectKind<"onHit">;
-/** For passives: `effects` happen around whoever the carrier kills. The killing sets it off, see `onKill` */
-export declare const onKillEffect: import("../effects").EffectKind<"onKill">;
-/** For passives: `effects` happen to the carrier whenever it casts. The casting sets it off, see `onCast` */
-export declare const onCastEffect: import("../effects").EffectKind<"onCast">;
+/** `onHit` is about attacks, not about the moment of casting: an attack landing sets it off (`attackLanded`) */
+export declare const onHitEffect: import("../effects").EffectType<"onHit">;
+/** For passives: `effects` happen around whoever the carrier kills. The killing sets it off, see `killTriggers` */
+export declare const onKillEffect: import("../effects").EffectType<"onKill">;
+/** For passives: `effects` happen to the carrier whenever it casts. The casting sets it off, see `castTriggers` */
+export declare const onCastEffect: import("../effects").EffectType<"onCast">;
+/** For passives: `effects` happen to who hurt the carrier. Being hurt sets it off, see `damageTriggers` */
+export declare const onDamagedEffect: import("../effects").EffectType<"onDamaged">;
+/** For passives: `effects` happen to an enemy an ability of the carrier hurt. The hurt sets it off, see `damageTriggers` */
+export declare const onAbilityHitEffect: import("../effects").EffectType<"onAbilityHit">;
+/** For passives: `effects` happen to the carrier as its health falls below `below`. See `damageTriggers` */
+export declare const onLowHealthEffect: import("../effects").EffectType<"onLowHealth">;
+/** For passives: instead of dying the carrier is left with `health` of its max, and `effects` happen to it. See `cheatDeath` */
+export declare const onFatalEffect: import("../effects").EffectType<"onFatal">;
+/** Takes `buff` off what it reaches: `stacks` of it, all of it when left out (`removeStacks`) */
+export declare const removeBuffEffect: import("../effects").EffectType<"removeBuff">;
 /** The caster is ready to strike again at once */
-export declare const resetAttackEffect: import("../effects").EffectKind<"resetAttack">;
+export declare const resetAttackEffect: import("../effects").EffectType<"resetAttack">;
 /** An ability of the caster is ready again, with all the charges it holds: the one named, or the one the effect belongs to */
-export declare const refreshEffect: import("../effects").EffectKind<"refresh">;
+export declare const refreshEffect: import("../effects").EffectType<"refresh">;
 /**
  * `effects` when the ability went off charged, `otherwise` when it did not. With `on: 'caster'` what it does
  * charged happens where the caster stands, wherever it was aimed
  */
-export declare const chargedEffect: import("../effects").EffectKind<"charged">;
+export declare const chargedEffect: import("../effects").EffectType<"charged">;

package/dist/abilities/effects/passives.js

@@ -0,0 +1,131 @@
+import { fighting } from "../../entity.js";
+import { readyAgain } from "../charges.js";
+import { run } from "../land.js";
+import { valueOf } from "../amounts.js";
+import { defineEffect, effectTargets } from "../effects.js";
+import { removeStacks } from "../triggers.js";
+//#region src/abilities/effects/passives.ts
+/**
+* What an ability does around its casting: the passives set off by attacks, kills and casts (`EffectTypes.onHit`,
+* `onKill`, `onCast`, run where those happen), an attack or an ability ready again (`resetAttack`, `refresh`), and what
+* a charged cast does (`charged`)
+*/
+/** `onHit` is about attacks, not about the moment of casting: an attack landing sets it off (`attackLanded`) */
+var onHitEffect = defineEffect({
+	type: "onHit",
+	run: () => {},
+	fields: [
+		"whileBuff",
+		"every",
+		"consumes",
+		"cooldown",
+		"slot",
+		"priority",
+		"effects"
+	]
+});
+/** For passives: `effects` happen around whoever the carrier kills. The killing sets it off, see `killTriggers` */
+var onKillEffect = defineEffect({
+	type: "onKill",
+	run: () => {},
+	fields: [
+		"attack",
+		"whileBuff",
+		"cooldown",
+		"effects"
+	]
+});
+/** For passives: `effects` happen to the carrier whenever it casts. The casting sets it off, see `castTriggers` */
+var onCastEffect = defineEffect({
+	type: "onCast",
+	run: () => {},
+	fields: ["cooldown", "effects"]
+});
+/** For passives: `effects` happen to who hurt the carrier. Being hurt sets it off, see `damageTriggers` */
+var onDamagedEffect = defineEffect({
+	type: "onDamaged",
+	run: () => {},
+	fields: [
+		"attack",
+		"melee",
+		"cooldown",
+		"effects"
+	]
+});
+/** For passives: `effects` happen to an enemy an ability of the carrier hurt. The hurt sets it off, see `damageTriggers` */
+var onAbilityHitEffect = defineEffect({
+	type: "onAbilityHit",
+	run: () => {},
+	fields: ["cooldown", "effects"]
+});
+/** For passives: `effects` happen to the carrier as its health falls below `below`. See `damageTriggers` */
+var onLowHealthEffect = defineEffect({
+	type: "onLowHealth",
+	run: () => {},
+	fields: [
+		"below",
+		"cooldown",
+		"effects"
+	]
+});
+/** For passives: instead of dying the carrier is left with `health` of its max, and `effects` happen to it. See `cheatDeath` */
+var onFatalEffect = defineEffect({
+	type: "onFatal",
+	run: () => {},
+	fields: [
+		"health",
+		"cooldown",
+		"effects"
+	]
+});
+/** Takes `buff` off what it reaches: `stacks` of it, all of it when left out (`removeStacks`) */
+var removeBuffEffect = defineEffect({
+	type: "removeBuff",
+	run: (context, effect) => {
+		if (!effect.buff) return;
+		const count = effect.stacks === void 0 ? void 0 : Math.max(Math.round(valueOf(context, effect.stacks)), 1);
+		const fallback = context.world.registry.buff(effect.buff).harmful ? "allies" : "enemies";
+		for (const entity of effectTargets(context, effect, fallback)) removeStacks(context.world, entity, effect.buff, count);
+	},
+	fields: ["buff", "stacks"]
+});
+/** The caster is ready to strike again at once */
+var resetAttackEffect = defineEffect({
+	type: "resetAttack",
+	run: ({ caster }) => {
+		if (caster.get(fighting)) caster.get(fighting).cooldown = 0;
+	},
+	fields: []
+});
+/** An ability of the caster is ready again, with all the charges it holds: the one named, or the one the effect belongs to */
+var refreshEffect = defineEffect({
+	type: "refresh",
+	run: (context, effect) => {
+		const state = context.caster.abilities.find((known) => known.id === (effect.ability ?? context.ability.id));
+		if (state) readyAgain(state);
+	},
+	fields: ["ability"]
+});
+/**
+* `effects` when the ability went off charged, `otherwise` when it did not. With `on: 'caster'` what it does
+* charged happens where the caster stands, wherever it was aimed
+*/
+var chargedEffect = defineEffect({
+	type: "charged",
+	run: (context, effect) => {
+		if (!context.charged) return run(context, effect.otherwise);
+		const { caster } = context;
+		run(effect.on === "caster" ? {
+			...context,
+			point: {
+				x: caster.pos.x,
+				z: caster.pos.z
+			}
+		} : context, effect.effects);
+	},
+	fields: ["effects", "otherwise"]
+});
+//#endregion
+export { chargedEffect, onAbilityHitEffect, onCastEffect, onDamagedEffect, onFatalEffect, onHitEffect, onKillEffect, onLowHealthEffect, refreshEffect, removeBuffEffect, resetAttackEffect };
+
+//# sourceMappingURL=passives.js.map

package/dist/abilities/effects/passives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"passives.js","names":[],"sources":["../../../src/abilities/effects/passives.ts"],"sourcesContent":["/**\n * What an ability does around its casting: the passives set off by attacks, kills and casts (`EffectTypes.onHit`,\n * `onKill`, `onCast`, run where those happen), an attack or an ability ready again (`resetAttack`, `refresh`), and what\n * a charged cast does (`charged`)\n */\nimport { fighting } from '#engine/entity'\nimport { defineEffect, effectTargets } from '../effects'\nimport { valueOf } from '../amounts'\nimport { removeStacks } from '../triggers'\nimport { run } from '../land'\nimport { readyAgain } from '../charges'\n\n/** `onHit` is about attacks, not about the moment of casting: an attack landing sets it off (`attackLanded`) */\nexport const onHitEffect = defineEffect({ type: 'onHit', run: () => {}, fields: ['whileBuff', 'every', 'consumes', 'cooldown', 'slot', 'priority', 'effects'] })\n\n/** For passives: `effects` happen around whoever the carrier kills. The killing sets it off, see `killTriggers` */\nexport const onKillEffect = defineEffect({ type: 'onKill', run: () => {}, fields: ['attack', 'whileBuff', 'cooldown', 'effects'] })\n\n/** For passives: `effects` happen to the carrier whenever it casts. The casting sets it off, see `castTriggers` */\nexport const onCastEffect = defineEffect({ type: 'onCast', run: () => {}, fields: ['cooldown', 'effects'] })\n\n/** For passives: `effects` happen to who hurt the carrier. Being hurt sets it off, see `damageTriggers` */\nexport const onDamagedEffect = defineEffect({ type: 'onDamaged', run: () => {}, fields: ['attack', 'melee', 'cooldown', 'effects'] })\n\n/** For passives: `effects` happen to an enemy an ability of the carrier hurt. The hurt sets it off, see `damageTriggers` */\nexport const onAbilityHitEffect = defineEffect({ type: 'onAbilityHit', run: () => {}, fields: ['cooldown', 'effects'] })\n\n/** For passives: `effects` happen to the carrier as its health falls below `below`. See `damageTriggers` */\nexport const onLowHealthEffect = defineEffect({ type: 'onLowHealth', run: () => {}, fields: ['below', 'cooldown', 'effects'] })\n\n/** For passives: instead of dying the carrier is left with `health` of its max, and `effects` happen to it. See `cheatDeath` */\nexport const onFatalEffect = defineEffect({ type: 'onFatal', run: () => {}, fields: ['health', 'cooldown', 'effects'] })\n\n/** Takes `buff` off what it reaches: `stacks` of it, all of it when left out (`removeStacks`) */\nexport const removeBuffEffect = defineEffect({ type: 'removeBuff', run: (context, effect) => {\n\t\tif (!effect.buff) return\n\t\tconst count = effect.stacks === undefined ? undefined : Math.max(Math.round(valueOf(context, effect.stacks)), 1)\n\t\tconst fallback = context.world.registry.buff(effect.buff).harmful ? 'allies' : 'enemies'\n\t\tfor (const entity of effectTargets(context, effect, fallback)) removeStacks(context.world, entity, effect.buff, count)\n\t}, fields: ['buff', 'stacks'] })\n\n/** The caster is ready to strike again at once */\nexport const resetAttackEffect = defineEffect({ type: 'resetAttack', run: ({ caster }) => {\n\t\tif (caster.get(fighting)) caster.get(fighting)!.cooldown = 0\n\t}, fields: [] })\n\n/** An ability of the caster is ready again, with all the charges it holds: the one named, or the one the effect belongs to */\nexport const refreshEffect = defineEffect({ type: 'refresh', run: (context, effect) => {\n\t\tconst state = context.caster.abilities.find((known) => known.id === (effect.ability ?? context.ability.id))\n\t\tif (state) readyAgain(state)\n\t}, fields: ['ability'] })\n\n/**\n * `effects` when the ability went off charged, `otherwise` when it did not. With `on: 'caster'` what it does\n * charged happens where the caster stands, wherever it was aimed\n */\nexport const chargedEffect = defineEffect({ type: 'charged', run: (context, effect) => {\n\t\tif (!context.charged) return run(context, effect.otherwise)\n\t\tconst { caster } = context\n\t\trun(effect.on === 'caster' ? { ...context, point: { x: caster.pos.x, z: caster.pos.z } } : context, effect.effects)\n\t}, fields: ['effects', 'otherwise'] })\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAa,cAAc,aAAa;CAAE,MAAM;CAAS,WAAW,CAAC;CAAG,QAAQ;EAAC;EAAa;EAAS;EAAY;EAAY;EAAQ;EAAY;CAAS;AAAE,CAAC;;AAG/J,IAAa,eAAe,aAAa;CAAE,MAAM;CAAU,WAAW,CAAC;CAAG,QAAQ;EAAC;EAAU;EAAa;EAAY;CAAS;AAAE,CAAC;;AAGlI,IAAa,eAAe,aAAa;CAAE,MAAM;CAAU,WAAW,CAAC;CAAG,QAAQ,CAAC,YAAY,SAAS;AAAE,CAAC;;AAG3G,IAAa,kBAAkB,aAAa;CAAE,MAAM;CAAa,WAAW,CAAC;CAAG,QAAQ;EAAC;EAAU;EAAS;EAAY;CAAS;AAAE,CAAC;;AAGpI,IAAa,qBAAqB,aAAa;CAAE,MAAM;CAAgB,WAAW,CAAC;CAAG,QAAQ,CAAC,YAAY,SAAS;AAAE,CAAC;;AAGvH,IAAa,oBAAoB,aAAa;CAAE,MAAM;CAAe,WAAW,CAAC;CAAG,QAAQ;EAAC;EAAS;EAAY;CAAS;AAAE,CAAC;;AAG9H,IAAa,gBAAgB,aAAa;CAAE,MAAM;CAAW,WAAW,CAAC;CAAG,QAAQ;EAAC;EAAU;EAAY;CAAS;AAAE,CAAC;;AAGvH,IAAa,mBAAmB,aAAa;CAAE,MAAM;CAAc,MAAM,SAAS,WAAW;EAC3F,IAAI,CAAC,OAAO,MAAM;EAClB,MAAM,QAAQ,OAAO,WAAW,KAAA,IAAY,KAAA,IAAY,KAAK,IAAI,KAAK,MAAM,QAAQ,SAAS,OAAO,MAAM,CAAC,GAAG,CAAC;EAC/G,MAAM,WAAW,QAAQ,MAAM,SAAS,KAAK,OAAO,IAAI,CAAC,CAAC,UAAU,WAAW;EAC/E,KAAK,MAAM,UAAU,cAAc,SAAS,QAAQ,QAAQ,GAAG,aAAa,QAAQ,OAAO,QAAQ,OAAO,MAAM,KAAK;CACtH;CAAG,QAAQ,CAAC,QAAQ,QAAQ;AAAE,CAAC;;AAGhC,IAAa,oBAAoB,aAAa;CAAE,MAAM;CAAe,MAAM,EAAE,aAAa;EACxF,IAAI,OAAO,IAAI,QAAQ,GAAG,OAAO,IAAI,QAAQ,CAAC,CAAE,WAAW;CAC5D;CAAG,QAAQ,CAAC;AAAE,CAAC;;AAGhB,IAAa,gBAAgB,aAAa;CAAE,MAAM;CAAW,MAAM,SAAS,WAAW;EACrF,MAAM,QAAQ,QAAQ,OAAO,UAAU,MAAM,UAAU,MAAM,QAAQ,OAAO,WAAW,QAAQ,QAAQ,GAAG;EAC1G,IAAI,OAAO,WAAW,KAAK;CAC5B;CAAG,QAAQ,CAAC,SAAS;AAAE,CAAC;;;;;AAMzB,IAAa,gBAAgB,aAAa;CAAE,MAAM;CAAW,MAAM,SAAS,WAAW;EACrF,IAAI,CAAC,QAAQ,SAAS,OAAO,IAAI,SAAS,OAAO,SAAS;EAC1D,MAAM,EAAE,WAAW;EACnB,IAAI,OAAO,OAAO,WAAW;GAAE,GAAG;GAAS,OAAO;IAAE,GAAG,OAAO,IAAI;IAAG,GAAG,OAAO,IAAI;GAAE;EAAE,IAAI,SAAS,OAAO,OAAO;CACnH;CAAG,QAAQ,CAAC,WAAW,WAAW;AAAE,CAAC"}

package/dist/abilities/effects/proxy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sends the proxy an effect goes off from to where it was aimed (`EffectTypes.sendProxy`): at once, its effects there
+ * from it; or at its `speed`, dragged there in the caster's name (a `pull` of the caster's), its effects as it arrives
+ */
+export declare const sendProxyEffect: import("../effects").EffectType<"sendProxy">;

package/dist/abilities/effects/proxy.js

@@ -0,0 +1,60 @@
+import { land } from "../land.js";
+import { dashing } from "../../dashing.js";
+import { defineEffect, startDash } from "../effects.js";
+//#region src/abilities/effects/proxy.ts
+/**
+* The proxy's own effect (E2E-PLAN AB17): the unit an effect goes off from (`EffectCommon.origin`) sent to where it was aimed
+*/
+/** The unit the effects go off from, where that is one of the caster's and not the caster */
+var sent = (context) => {
+	const { origin, caster } = context;
+	return origin && "pos" in origin && origin !== caster ? origin : void 0;
+};
+/**
+* Sends the proxy an effect goes off from to where it was aimed (`EffectTypes.sendProxy`): at once, its effects there
+* from it; or at its `speed`, dragged there in the caster's name (a `pull` of the caster's), its effects as it arrives
+*/
+var sendProxyEffect = defineEffect({
+	type: "sendProxy",
+	run: (context, effect) => {
+		const { world, caster, ability, level, point } = context;
+		const proxy = sent(context);
+		if (!proxy?.alive || proxy.isStructure || proxy.get(dashing)) return;
+		const to = {
+			x: point.x,
+			z: point.z
+		};
+		if (!effect.speed) {
+			world.place(proxy, to);
+			proxy.prevPos.x = to.x;
+			proxy.prevPos.z = to.z;
+			land({
+				world,
+				caster,
+				ability,
+				level,
+				target: proxy,
+				point: to,
+				origin: proxy
+			}, effect.effects);
+			return;
+		}
+		startDash(world, proxy, {
+			x: to.x,
+			z: to.z,
+			speed: effect.speed,
+			ability: ability.id,
+			level,
+			effects: effect.effects ?? [],
+			pulled: {
+				by: caster.id,
+				follows: false
+			}
+		});
+	},
+	fields: ["speed", "effects"]
+});
+//#endregion
+export { sendProxyEffect };
+
+//# sourceMappingURL=proxy.js.map

package/dist/abilities/effects/proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.js","names":[],"sources":["../../../src/abilities/effects/proxy.ts"],"sourcesContent":["/**\n * The proxy's own effect (E2E-PLAN AB17): the unit an effect goes off from (`EffectCommon.origin`) sent to where it was aimed\n */\nimport { dashing } from '#engine/dashing'\nimport type { Entity } from '#engine/entity'\nimport { defineEffect, type EffectContext, startDash } from '../effects'\nimport { land } from '../land'\n\n/** The unit the effects go off from, where that is one of the caster's and not the caster */\nconst sent = (context: EffectContext): Entity | undefined => {\n\tconst { origin, caster } = context\n\treturn origin && 'pos' in origin && origin !== caster ? (origin as Entity) : undefined\n}\n\n/**\n * Sends the proxy an effect goes off from to where it was aimed (`EffectTypes.sendProxy`): at once, its effects there\n * from it; or at its `speed`, dragged there in the caster's name (a `pull` of the caster's), its effects as it arrives\n */\nexport const sendProxyEffect = defineEffect({\n\ttype: 'sendProxy',\n\trun: (context, effect) => {\n\t\tconst { world, caster, ability, level, point } = context\n\t\tconst proxy = sent(context)\n\t\tif (!proxy?.alive || proxy.isStructure || proxy.get(dashing)) return\n\t\tconst to = { x: point.x, z: point.z }\n\t\tif (!effect.speed) {\n\t\t\tworld.place(proxy, to)\n\t\t\tproxy.prevPos.x = to.x\n\t\t\tproxy.prevPos.z = to.z\n\t\t\tland({ world, caster, ability, level, target: proxy, point: to, origin: proxy }, effect.effects)\n\t\t\treturn\n\t\t}\n\t\tstartDash(world, proxy, { x: to.x, z: to.z, speed: effect.speed, ability: ability.id, level, effects: effect.effects ?? [], pulled: { by: caster.id, follows: false } })\n\t},\n\tfields: ['speed', 'effects']\n})\n"],"mappings":";;;;;;;;AASA,IAAM,QAAQ,YAA+C;CAC5D,MAAM,EAAE,QAAQ,WAAW;CAC3B,OAAO,UAAU,SAAS,UAAU,WAAW,SAAU,SAAoB,KAAA;AAC9E;;;;;AAMA,IAAa,kBAAkB,aAAa;CAC3C,MAAM;CACN,MAAM,SAAS,WAAW;EACzB,MAAM,EAAE,OAAO,QAAQ,SAAS,OAAO,UAAU;EACjD,MAAM,QAAQ,KAAK,OAAO;EAC1B,IAAI,CAAC,OAAO,SAAS,MAAM,eAAe,MAAM,IAAI,OAAO,GAAG;EAC9D,MAAM,KAAK;GAAE,GAAG,MAAM;GAAG,GAAG,MAAM;EAAE;EACpC,IAAI,CAAC,OAAO,OAAO;GAClB,MAAM,MAAM,OAAO,EAAE;GACrB,MAAM,QAAQ,IAAI,GAAG;GACrB,MAAM,QAAQ,IAAI,GAAG;GACrB,KAAK;IAAE;IAAO;IAAQ;IAAS;IAAO,QAAQ;IAAO,OAAO;IAAI,QAAQ;GAAM,GAAG,OAAO,OAAO;GAC/F;EACD;EACA,UAAU,OAAO,OAAO;GAAE,GAAG,GAAG;GAAG,GAAG,GAAG;GAAG,OAAO,OAAO;GAAO,SAAS,QAAQ;GAAI;GAAO,SAAS,OAAO,WAAW,CAAC;GAAG,QAAQ;IAAE,IAAI,OAAO;IAAI,SAAS;GAAM;EAAE,CAAC;CACxK;CACA,QAAQ,CAAC,SAAS,SAAS;AAC5B,CAAC"}

package/dist/abilities/effects/sight.d.ts

@@ -1,4 +1,4 @@
 /** The caster's team sees the spot for a while, with nothing standing there */
-export declare const revealEffect: import("../effects").EffectKind<"reveal">;
+export declare const revealEffect: import("../effects").EffectType<"reveal">;
 /** Finds what is invisible around the spot: the caster's team sees it for as long as `duration` says */
-export declare const detectEffect: import("../effects").EffectKind<"detect">;
+export declare const detectEffect: import("../effects").EffectType<"detect">;