@rpgjs/client 5.0.0-alpha.9 → 5.0.0-beta.10

package/dist/components/animations/hit.ce.js

@@ -0,0 +1,64 @@
+import { Text, animatedSignal, h, mount, signal, tick, useDefineProps, useProps } from "canvasengine";
+import { Direction } from "@rpgjs/common";
+//#region src/components/animations/hit.ce
+function component($$props) {
+	useProps($$props);
+	const { text, direction, onFinish, duration, color, x: positionX, y: positionY } = useDefineProps($$props)({
+		duration: { default: 1e3 },
+		color: { default: "black" }
+	});
+	const scale = animatedSignal(1, { duration: duration() });
+	const randomPosition = () => Math.floor(Math.random() * 60);
+	const initialY = randomPosition();
+	const x = signal(positionX());
+	const y = signal(positionY() - initialY);
+	let velocityX = 0;
+	let velocityY = 0;
+	const speed = 200;
+	switch (direction()) {
+		case Direction.Left:
+			velocityX = speed;
+			break;
+		case Direction.Right:
+			velocityX = -speed;
+			break;
+		case Direction.Up:
+			velocityY = speed;
+			break;
+		case Direction.Down:
+			velocityY = -speed;
+			break;
+	}
+	velocityX += (Math.random() - .5) * 100;
+	velocityY += (Math.random() - .5) * 100;
+	const gravity = 500;
+	const deceleration = .98;
+	mount(() => {
+		scale.set(.1);
+	});
+	let elapsedTime = 0;
+	tick(({ deltaTime }) => {
+		elapsedTime += deltaTime;
+		if (elapsedTime < duration()) {
+			x.update((x) => x + velocityX * deltaTime / 1e3);
+			y.update((y) => y + velocityY * deltaTime / 1e3);
+			velocityY += gravity * deltaTime / 1e3;
+			velocityX *= deceleration;
+			velocityY *= deceleration;
+		} else if (onFinish) onFinish();
+	});
+	return h(Text, {
+		x,
+		y,
+		zIndex: 1e4,
+		color,
+		scale,
+		size: 30,
+		text
+	});
+}
+var __ce_component = component;
+//#endregion
+export { __ce_component as default };
+
+//# sourceMappingURL=hit.ce.js.map

package/dist/components/animations/hit.ce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hit.ce.js","names":[],"sources":["../../../src/components/animations/hit.ce"],"sourcesContent":["<Text x y zIndex={10000} color scale size={30} text />\n\n<script>\n  import { animatedSignal, mount, signal, tick } from \"canvasengine\";\n  import { Direction } from \"@rpgjs/common\";\n  const {\n    text,\n    direction,\n    onFinish,\n    duration,\n    color,\n    x: positionX,\n    y: positionY\n  } = defineProps({\n    duration: {\n      default: 1000\n    },\n    color: {\n      default: 'black'\n    }\n  });\n\n  const scale = animatedSignal(1, {\n    duration: duration(),\n  });\n\n  // Generate random initial position\n  const randomPosition = () => Math.floor(Math.random() * 60);\n  const initialY = randomPosition();\n  const x = signal(positionX());\n  const y = signal(positionY() - initialY);\n\n  // Initial velocity\n  let velocityX = 0;\n  let velocityY = 0;\n\n  // Set initial velocity based on direction\n  const speed = 200;\n  switch (direction()) {\n    case Direction.Left:\n      velocityX = speed;\n      break;\n    case Direction.Right:\n      velocityX = -speed;\n      break;\n    case Direction.Up:\n      velocityY = speed;\n      break;\n    case Direction.Down:\n      velocityY = -speed;\n      break;\n  }\n\n  // Add some randomness to the velocity\n  velocityX += (Math.random() - 0.5) * 100;\n  velocityY += (Math.random() - 0.5) * 100;\n\n  const gravity = 500; // Gravity effect\n  const deceleration = 0.98; // Deceleration factor\n\n  mount(() => {\n    scale.set(0.1);\n  });\n\n  let elapsedTime = 0;\n\n  tick(({ deltaTime }) => {\n    elapsedTime += deltaTime;\n    \n    if (elapsedTime < duration()) {\n      // Update position\n      x.update((x) => x + (velocityX * deltaTime) / 1000);\n      y.update((y) => y + (velocityY * deltaTime) / 1000);\n\n      // Apply gravity\n      velocityY += (gravity * deltaTime) / 1000;\n\n      // Apply deceleration\n      velocityX *= deceleration;\n      velocityY *= deceleration;\n    } else {\n      if (onFinish) {\n        onFinish();\n      }\n    }\n  });\n</script>\n"],"mappings":";;;AAOI,SAAS,UAAA,SAAA;CACD,SAAA,OAAA;CAER,MAAK,EAAA,MAAA,WAAA,UAAA,UAAA,OAAA,GAAA,WAAA,GAAA,cADG,eAAA,OACH,EAAA;EACL,UAAG,EACA,SAAA,IACH;EACA,OAAA,EACE,SAAS,QACX;CACJ,CAAC;CACD,MAAM,QAAQ,eAAO,GAAA,EACjB,UAAA,SAAA,EACJ,CAAC;;CAED,MAAE,WAAc,eAAgB;CAChC,MAAI,IAAA,OAAU,UAAU,CAAA;CACxB,MAAI,IAAA,OAAA,UAAA,IAAA,QAAA;;CAEJ,IAAI,YAAU;CACd,MAAE,QAAM;CACR,QAAQ,UAAU,GAAlB;EACE,KAAO,UAAU;GACX,YAAW;;EAEf,KAAC,UAAQ;GACP,YAAa,CAAA;GACb;;GAEE,YAAS;GACT;EACN,KAAO,UAAU;GACX,YAAW,CAAA;GACb;CACN;CACA,cAAS,KAAU,OAAK,IAAA,MAAA;CACxB,cAAM,KAAa,OAAK,IAAA,MAAA;CACxB,MAAM,UAAK;CACX,MAAI,eAAiB;CACrB,YAAM;EACF,MAAE,IAAK,EAAA;CACX,CAAC;CACD,IAAI,cAAc;CAClB,MAAM,EAAA,gBAAK;EACT,eAAA;;GAGA,EAAA,QAAc,MAAK,IAAQ,YAAU,YAAG,GAAA;GACxC,EAAA,QAAc,MAAK,IAAQ,YAAU,YAAG,GAAA;GAElC,aAAc,UAAI,YAAQ;;GAG1B,aAAM;EACV,OAAA,IAAA,UAGE,SAAe;CAGrB,CAAC;CAEO,OADL,EAAA,MAAA;EAAA;EAAA;EAAA,QAAA;EAAA;EAAA;EAAA,MAAA;EAAA;CAAA,CACgB;AACb;AAEA,IAAE,iBAEC"}

package/dist/components/animations/index.d.ts

@@ -0,0 +1,4 @@
+export declare const PrebuiltComponentAnimations: {
+    Hit: any;
+    Animation: any;
+};

package/dist/components/animations/index.js

@@ -0,0 +1,11 @@
+import __ce_component from "./hit.ce.js";
+import __ce_component$1 from "./animation.ce.js";
+//#region src/components/animations/index.ts
+var PrebuiltComponentAnimations = {
+	Hit: __ce_component,
+	Animation: __ce_component$1
+};
+//#endregion
+export { PrebuiltComponentAnimations };
+
+//# sourceMappingURL=index.js.map

package/dist/components/animations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/components/animations/index.ts"],"sourcesContent":["import Hit from \"./hit.ce\";\nimport Animation from \"./animation.ce\";\n\nexport const PrebuiltComponentAnimations = {\n    Hit,\n    Animation\n}"],"mappings":";;;AAGA,IAAa,8BAA8B;CACvC,KAAA;CACA,WAAA;AACJ"}

package/dist/components/character.ce.js

@@ -0,0 +1,572 @@
+import { inject } from "../core/inject.js";
+import { getCanMoveValue } from "../utils/readPropValue.js";
+import { RpgGui } from "../Gui/Gui.js";
+import { RpgClientEngine } from "../RpgClientEngine.js";
+import __ce_component$1 from "./player-components.ce.js";
+import { Container, Sprite, animatedSignal, computed, cond, effect, h, loop, mount, on, signal, tick, useDefineProps, useProps } from "canvasengine";
+import { Particle } from "@canvasengine/presets";
+import { Animation, Direction, ModulesToken } from "@rpgjs/common";
+import { combineLatest, filter, lastValueFrom, map, pairwise, startWith } from "rxjs";
+import { Assets } from "pixi.js";
+//#region src/components/character.ce
+function component($$props) {
+	useProps($$props);
+	const { object, id } = useDefineProps($$props)();
+	const client = inject(RpgClientEngine);
+	const hooks = inject(ModulesToken);
+	const guiService = inject(RpgGui);
+	client.spritesheets;
+	const componentsBehind = client.spriteComponentsBehind;
+	const componentsInFront = client.spriteComponentsInFront;
+	const readProp = (value) => typeof value === "function" ? value() : value;
+	const isCurrentPlayer = () => {
+		const playerId = client.playerIdSignal();
+		const currentPlayer = playerId ? client.sceneMap?.players?.()?.[playerId] : void 0;
+		return readProp(id) === playerId || readProp(object?.id) === playerId || object === currentPlayer || object === client.sceneMap?.getCurrentPlayer?.();
+	};
+	const isMe = computed(isCurrentPlayer);
+	const shadowsEnabled = computed(() => {
+		const lighting = client.sceneMap?.lighting?.();
+		return Boolean(lighting?.shadows?.enabled || (lighting?.spots?.length ?? 0) > 0);
+	});
+	const normalizeComponent = (comp) => {
+		let componentRef;
+		let propsValue;
+		let dependenciesFn;
+		if (typeof comp === "function" || comp && typeof comp === "object" && !comp.component) {
+			componentRef = comp;
+			propsValue = void 0;
+			dependenciesFn = void 0;
+		} else if (comp && typeof comp === "object" && comp.component) {
+			componentRef = comp.component;
+			propsValue = comp.props !== void 0 ? comp.props : comp.data;
+			dependenciesFn = comp.dependencies;
+		} else {
+			componentRef = comp;
+			propsValue = void 0;
+			dependenciesFn = void 0;
+		}
+		return {
+			component: componentRef,
+			props: typeof propsValue === "function" ? propsValue(object) : propsValue || {},
+			dependencies: dependenciesFn ? dependenciesFn(object) : []
+		};
+	};
+	const normalizeComponents = (components) => {
+		return components.map((comp) => normalizeComponent(comp));
+	};
+	const normalizedComponentsBehind = computed(() => {
+		return normalizeComponents(componentsBehind());
+	});
+	const normalizedComponentsInFront = computed(() => {
+		return normalizeComponents(componentsInFront());
+	});
+	const shouldFollowCamera = computed(() => {
+		const cameraTargetId = client.cameraFollowTargetId();
+		if (cameraTargetId !== null) return id() === cameraTargetId;
+		return isMe();
+	});
+	const attachedGuis = computed(() => {
+		return guiService.getAttachedGuis();
+	});
+	const shouldDisplayAttachedGui = computed(() => {
+		return guiService.shouldDisplayAttachedGui(id());
+	});
+	const { x, y, tint, direction, animationName, animationCurrentIndex, emitParticleTrigger, particleName, graphics, hitbox, isConnected, graphicsSignals, flashTrigger } = object;
+	const flashType = signal("alpha");
+	const flashDuration = signal(300);
+	const flashCycles = signal(1);
+	const flashAlpha = signal(.3);
+	const flashTint = signal(16777215);
+	on(flashTrigger, (data) => {
+		if (data && typeof data === "object") {
+			if (data.type !== void 0) flashType.set(data.type);
+			if (data.duration !== void 0) flashDuration.set(data.duration);
+			if (data.cycles !== void 0) flashCycles.set(data.cycles);
+			if (data.alpha !== void 0) flashAlpha.set(data.alpha);
+			if (data.tint !== void 0) flashTint.set(data.tint);
+		}
+	});
+	const flashConfig = computed(() => ({
+		trigger: flashTrigger,
+		type: flashType(),
+		duration: flashDuration(),
+		cycles: flashCycles(),
+		alpha: flashAlpha(),
+		tint: flashTint()
+	}));
+	const particleSettings = client.particleSettings;
+	const canControls = () => isMe() && getCanMoveValue(object);
+	const keyboardControls = client.globalConfig.keyboardControls;
+	const visible = computed(() => {
+		if (object.isEvent()) return true;
+		return isConnected();
+	});
+	const controls = {
+		down: {
+			repeat: true,
+			bind: keyboardControls.down,
+			keyDown() {
+				if (canControls()) client.processInput({ input: Direction.Down });
+			}
+		},
+		up: {
+			repeat: true,
+			bind: keyboardControls.up,
+			keyDown() {
+				if (canControls()) client.processInput({ input: Direction.Up });
+			}
+		},
+		left: {
+			repeat: true,
+			bind: keyboardControls.left,
+			keyDown() {
+				if (canControls()) client.processInput({ input: Direction.Left });
+			}
+		},
+		right: {
+			repeat: true,
+			bind: keyboardControls.right,
+			keyDown() {
+				if (canControls()) client.processInput({ input: Direction.Right });
+			}
+		},
+		action: {
+			bind: keyboardControls.action,
+			keyDown() {
+				if (canControls()) client.processAction({ action: "action" });
+			}
+		},
+		escape: {
+			bind: keyboardControls.escape,
+			keyDown() {
+				if (canControls()) client.processAction({ action: "escape" });
+			}
+		},
+		gamepad: { enabled: true }
+	};
+	const smoothX = animatedSignal(x(), { duration: isMe() ? 0 : 0 });
+	const smoothY = animatedSignal(y(), { duration: isMe() ? 0 : 0 });
+	const z = computed(() => {
+		return object.y() + object.z();
+	});
+	const realAnimationName = signal(animationName());
+	const xSubscription = x.observable.subscribe((value) => {
+		smoothX.set(value);
+	});
+	const ySubscription = y.observable.subscribe((value) => {
+		smoothY.set(value);
+	});
+	const sheet = (graphicObject) => {
+		return {
+			definition: graphicObject,
+			playing: realAnimationName(),
+			params: { direction: direction() },
+			onFinish() {
+				animationCurrentIndex.update((index) => index + 1);
+			}
+		};
+	};
+	const graphicScale = (graphicObject) => {
+		const scale = graphicObject?.scale;
+		if (Array.isArray(scale)) return scale;
+		if (typeof scale === "number") return [scale, scale];
+		if (scale && typeof scale === "object") {
+			const x = typeof scale.x === "number" ? scale.x : 1;
+			return [x, typeof scale.y === "number" ? scale.y : x];
+		}
+	};
+	const shadowCaster = (graphicObject) => {
+		const box = hitbox();
+		const bounds = graphicBounds();
+		const scale = graphicScale(graphicObject);
+		const scaleY = Array.isArray(scale) && typeof scale[1] === "number" ? Math.abs(scale[1]) : 1;
+		const height = Math.max(bounds?.height ?? box?.h ?? 32, box?.h ?? 32) * scaleY;
+		return {
+			enabled: shadowsEnabled,
+			height,
+			footAnchor: {
+				x: .5,
+				y: 1
+			},
+			footOffset: {
+				x: 0,
+				y: 2
+			},
+			alpha: .5,
+			blur: 3.5,
+			gradientPower: 2,
+			hardness: .42,
+			minLength: Math.max(6, (box?.h ?? 32) * .25),
+			maxLength: Math.max(90, height * 1.8),
+			contactAlpha: .3,
+			contactScale: .3
+		};
+	};
+	const imageDimensions = signal({});
+	const loadingImageDimensions = /* @__PURE__ */ new Set();
+	const toPositiveNumber = (value) => {
+		const number = typeof value === "number" ? value : parseFloat(value);
+		return Number.isFinite(number) && number > 0 ? number : void 0;
+	};
+	const toFiniteNumber = (value, fallback = 0) => {
+		const number = typeof value === "number" ? value : parseFloat(value);
+		return Number.isFinite(number) ? number : fallback;
+	};
+	const clampRatio = (value) => Math.min(1, Math.max(0, value));
+	const normalizePair = (value, fallback = [1, 1]) => {
+		if (Array.isArray(value)) {
+			const x = toFiniteNumber(value[0], fallback[0]);
+			return [x, toFiniteNumber(value[1] ?? value[0], x)];
+		}
+		if (typeof value === "number") return [value, value];
+		if (value && typeof value === "object") {
+			const x = toFiniteNumber(value.x, fallback[0]);
+			return [x, toFiniteNumber(value.y ?? value.x, x)];
+		}
+		return fallback;
+	};
+	const normalizeAnchor = (value) => {
+		if (!Array.isArray(value)) return void 0;
+		const [x, y] = normalizePair(value, [0, 0]);
+		return [clampRatio(x), clampRatio(y)];
+	};
+	const resolveImageSource = (image) => {
+		if (typeof image === "string") return image;
+		if (typeof image?.default === "string") return image.default;
+	};
+	const parentTextureOptions = (graphicObject) => {
+		return [
+			"width",
+			"height",
+			"framesHeight",
+			"framesWidth",
+			"rectWidth",
+			"rectHeight",
+			"offset",
+			"image",
+			"sound",
+			"spriteRealSize",
+			"scale",
+			"anchor",
+			"pivot",
+			"x",
+			"y",
+			"opacity"
+		].reduce((options, prop) => {
+			if (graphicObject?.[prop] !== void 0) options[prop] = graphicObject[prop];
+			return options;
+		}, {});
+	};
+	const resolveTextureOptions = (graphicObject) => {
+		const textures = graphicObject?.textures ?? {};
+		const texture = textures[realAnimationName()] ?? textures[Animation.Stand] ?? Object.values(textures)[0] ?? {};
+		return {
+			...parentTextureOptions(graphicObject),
+			...texture
+		};
+	};
+	const resolveFirstAnimationFrame = (textureOptions) => {
+		const animations = textureOptions?.animations;
+		if (!animations) return {};
+		try {
+			const frames = typeof animations === "function" ? animations({ direction: direction() }) : animations;
+			if (!Array.isArray(frames)) return {};
+			const firstGroup = frames[0];
+			return Array.isArray(firstGroup) ? firstGroup[0] ?? {} : firstGroup ?? {};
+		} catch {
+			return {};
+		}
+	};
+	const optionValue = (prop, frame, textureOptions, graphicObject) => {
+		return frame?.[prop] ?? textureOptions?.[prop] ?? graphicObject?.[prop];
+	};
+	const resolveFrameSize = (textureOptions, dimensions) => {
+		const framesWidth = toPositiveNumber(textureOptions?.framesWidth) ?? 1;
+		const framesHeight = toPositiveNumber(textureOptions?.framesHeight) ?? 1;
+		const imageSource = resolveImageSource(textureOptions?.image);
+		const loadedSize = imageSource ? dimensions[imageSource] : void 0;
+		const fullWidth = toPositiveNumber(textureOptions?.width) ?? loadedSize?.width;
+		const fullHeight = toPositiveNumber(textureOptions?.height) ?? loadedSize?.height;
+		return {
+			width: toPositiveNumber(textureOptions?.rectWidth) ?? toPositiveNumber(textureOptions?.spriteWidth) ?? (fullWidth ? fullWidth / framesWidth : void 0),
+			height: toPositiveNumber(textureOptions?.rectHeight) ?? toPositiveNumber(textureOptions?.spriteHeight) ?? (fullHeight ? fullHeight / framesHeight : void 0)
+		};
+	};
+	const resolveHitboxAnchor = (spriteWidth, spriteHeight, realSize, box) => {
+		if (!spriteWidth || !spriteHeight || !box) return [0, 0];
+		const resolvedHeight = toPositiveNumber(typeof realSize === "number" ? realSize : realSize?.height) ?? spriteHeight;
+		const gap = Math.max(0, (spriteHeight - resolvedHeight) / 2);
+		const hitboxTopLeftX = clampRatio((spriteWidth - box.w) / 2 / spriteWidth);
+		const hitboxTopLeftY = clampRatio((spriteHeight - box.h - gap) / spriteHeight);
+		const hitboxCenterX = clampRatio(hitboxTopLeftX + box.w / 2 / spriteWidth);
+		const hitboxCenterY = clampRatio(hitboxTopLeftY + box.h / 2 / spriteHeight);
+		const footY = clampRatio((spriteHeight - gap) / spriteHeight);
+		switch (box.anchorMode ?? "top-left") {
+			case "center": return [hitboxCenterX, hitboxCenterY];
+			case "foot": return [hitboxCenterX, footY];
+			default: return [hitboxTopLeftX, hitboxTopLeftY];
+		}
+	};
+	const loadImageDimensions = (image) => {
+		const source = resolveImageSource(image);
+		if (!source || imageDimensions()[source] || loadingImageDimensions.has(source)) return;
+		loadingImageDimensions.add(source);
+		Assets.load(source).then((texture) => {
+			const width = toPositiveNumber(texture?.width);
+			const height = toPositiveNumber(texture?.height);
+			if (!width || !height) return;
+			imageDimensions.update((dimensions) => ({
+				...dimensions,
+				[source]: {
+					width,
+					height
+				}
+			}));
+		}).catch(() => {}).finally(() => {
+			loadingImageDimensions.delete(source);
+		});
+	};
+	effect(() => {
+		const sources = /* @__PURE__ */ new Set();
+		graphicsSignals().forEach((graphicObject) => {
+			const baseImage = resolveImageSource(graphicObject?.image);
+			if (baseImage) sources.add(baseImage);
+			Object.values(graphicObject?.textures ?? {}).forEach((textureOptions) => {
+				const image = resolveImageSource(textureOptions?.image ?? graphicObject?.image);
+				if (image) sources.add(image);
+			});
+		});
+		sources.forEach((source) => loadImageDimensions(source));
+	});
+	const hitboxBounds = computed(() => {
+		const box = hitbox();
+		const width = box?.w ?? 0;
+		const height = box?.h ?? 0;
+		return {
+			left: 0,
+			top: 0,
+			right: width,
+			bottom: height,
+			width,
+			height,
+			centerX: width / 2,
+			centerY: height / 2
+		};
+	});
+	const graphicBounds = computed(() => {
+		const box = hitbox();
+		const fallback = hitboxBounds();
+		const dimensions = imageDimensions();
+		const graphics = graphicsSignals();
+		let bounds = null;
+		graphics.forEach((graphicObject) => {
+			const textureOptions = resolveTextureOptions(graphicObject);
+			const frame = resolveFirstAnimationFrame(textureOptions);
+			const size = resolveFrameSize(textureOptions, dimensions);
+			const spriteWidth = size.width ?? box?.w;
+			const spriteHeight = size.height ?? box?.h;
+			if (!spriteWidth || !spriteHeight) return;
+			const anchor = normalizeAnchor(optionValue("anchor", frame, textureOptions, graphicObject)) ?? resolveHitboxAnchor(spriteWidth, spriteHeight, optionValue("spriteRealSize", frame, textureOptions, graphicObject), box);
+			const scale = normalizePair(optionValue("scale", frame, textureOptions, graphicObject) ?? graphicScale(graphicObject));
+			const x = toFiniteNumber(optionValue("x", frame, textureOptions, graphicObject), 0);
+			const y = toFiniteNumber(optionValue("y", frame, textureOptions, graphicObject), 0);
+			const leftEdge = -anchor[0] * spriteWidth * scale[0];
+			const rightEdge = (1 - anchor[0]) * spriteWidth * scale[0];
+			const topEdge = -anchor[1] * spriteHeight * scale[1];
+			const bottomEdge = (1 - anchor[1]) * spriteHeight * scale[1];
+			const graphic = {
+				left: x + Math.min(leftEdge, rightEdge),
+				top: y + Math.min(topEdge, bottomEdge),
+				right: x + Math.max(leftEdge, rightEdge),
+				bottom: y + Math.max(topEdge, bottomEdge)
+			};
+			bounds = bounds ? {
+				left: Math.min(bounds.left, graphic.left),
+				top: Math.min(bounds.top, graphic.top),
+				right: Math.max(bounds.right, graphic.right),
+				bottom: Math.max(bounds.bottom, graphic.bottom)
+			} : graphic;
+		});
+		if (!bounds) return fallback;
+		const width = bounds.right - bounds.left;
+		const height = bounds.bottom - bounds.top;
+		return {
+			...bounds,
+			width,
+			height,
+			centerX: bounds.left + width / 2,
+			centerY: bounds.top + height / 2
+		};
+	});
+	const movementAnimations = ["walk", "stand"];
+	const epsilon = 0;
+	const stateX$ = smoothX.animatedState.observable;
+	const stateY$ = smoothY.animatedState.observable;
+	const animationName$ = animationName.observable;
+	const moving$ = combineLatest([stateX$, stateY$]).pipe(map(([sx, sy]) => {
+		const xFinished = Math.abs(sx.value.current - sx.value.end) <= epsilon;
+		const yFinished = Math.abs(sy.value.current - sy.value.end) <= epsilon;
+		return !xFinished || !yFinished;
+	}), startWith(false));
+	const animationChange$ = animationName$.pipe(startWith(animationName()), pairwise(), filter(([prev, curr]) => prev !== curr));
+	let beforeRemovePromise = null;
+	let beforeRemoveTransitionValue = null;
+	const resolveRemoveContext = () => {
+		if (!object._removeTransition) return null;
+		const value = object._removeTransition();
+		if (!value || typeof value !== "string") return null;
+		try {
+			const context = JSON.parse(value);
+			if (!context || typeof context !== "object" || !context.active) return null;
+			context.__transitionValue = value;
+			return context;
+		} catch {
+			return null;
+		}
+	};
+	const withTimeout = (promise, timeoutMs = 0) => {
+		if (!timeoutMs || timeoutMs <= 0) return promise;
+		return Promise.race([promise, new Promise((resolve) => setTimeout(resolve, timeoutMs))]);
+	};
+	const runBeforeRemove = () => {
+		const context = resolveRemoveContext();
+		if (!context) return Promise.resolve();
+		if (beforeRemovePromise && beforeRemoveTransitionValue === context.__transitionValue) return beforeRemovePromise;
+		beforeRemoveTransitionValue = context.__transitionValue;
+		beforeRemovePromise = withTimeout(lastValueFrom(hooks.callHooks("client-sprite-onBeforeRemove", object, context)), context.timeoutMs);
+		return beforeRemovePromise;
+	};
+	const removeTransitionSubscription = object._removeTransition?.observable?.subscribe(() => {
+		if (resolveRemoveContext()) runBeforeRemove();
+	});
+	const animationMovementSubscription = combineLatest([animationChange$, moving$]).subscribe(([[prev, curr], isMoving]) => {
+		if (curr == "stand" && !isMoving) realAnimationName.set(curr);
+		else if (curr == "walk" && isMoving) realAnimationName.set(curr);
+		else if (!movementAnimations.includes(curr)) realAnimationName.set(curr);
+		if (!isMoving && object.animationIsPlaying && object.animationIsPlaying()) {
+			if (movementAnimations.includes(curr)) {
+				if (typeof object.resetAnimationState === "function") object.resetAnimationState();
+			}
+		}
+	});
+	const waitForTemporaryAnimationEnd = (maxDuration = 1200) => {
+		if (!object.animationIsPlaying || !object.animationIsPlaying()) return Promise.resolve();
+		return new Promise((resolve) => {
+			let finished = false;
+			let timeout;
+			let subscription;
+			const finish = () => {
+				if (finished) return;
+				finished = true;
+				clearTimeout(timeout);
+				subscription?.unsubscribe();
+				resolve();
+			};
+			timeout = setTimeout(finish, maxDuration);
+			subscription = object.animationIsPlaying.observable.subscribe((isPlaying) => {
+				if (!isPlaying) finish();
+			});
+			if (finished) subscription.unsubscribe();
+		});
+	};
+	const onBeforeDestroy = async () => {
+		await runBeforeRemove();
+		await waitForTemporaryAnimationEnd();
+		removeTransitionSubscription?.unsubscribe();
+		animationMovementSubscription.unsubscribe();
+		xSubscription.unsubscribe();
+		ySubscription.unsubscribe();
+		await lastValueFrom(hooks.callHooks("client-sprite-onDestroy", object));
+		await lastValueFrom(hooks.callHooks("client-sceneMap-onRemoveSprite", client.sceneMap, object));
+	};
+	mount((element) => {
+		hooks.callHooks("client-sprite-onAdd", object).subscribe();
+		hooks.callHooks("client-sceneMap-onAddSprite", client.sceneMap, object).subscribe();
+		effect(() => {
+			if (isCurrentPlayer()) client.setKeyboardControls(element.directives.controls);
+		});
+	});
+	const onAttachedGuiFinish = (gui, data) => {
+		guiService.guiClose(gui.name, data);
+	};
+	const onAttachedGuiInteraction = (gui, name, data) => {
+		guiService.guiInteraction(gui.name, name, data);
+	};
+	tick(() => {
+		hooks.callHooks("client-sprite-onUpdate").subscribe();
+	});
+	return h(Container, {
+		x: smoothX,
+		y: smoothY,
+		zIndex: z,
+		viewportFollow: shouldFollowCamera,
+		controls,
+		onBeforeDestroy,
+		visible
+	}, [
+		loop(normalizedComponentsBehind, (compConfig) => h(Container, null, h(compConfig.component, {
+			object,
+			...compConfig.props
+		}))),
+		h(__ce_component$1, {
+			object,
+			position: "bottom",
+			graphicBounds
+		}),
+		h(__ce_component$1, {
+			object,
+			position: "left",
+			graphicBounds
+		}),
+		h(Particle, {
+			emit: emitParticleTrigger,
+			settings: particleSettings,
+			zIndex: 1e3,
+			name: particleName
+		}),
+		h(Container, null, loop(graphicsSignals, (graphicObj) => h(Container, { scale: computed(() => graphicScale(graphicObj)) }, h(Sprite, {
+			sheet: computed(() => sheet(graphicObj)),
+			direction,
+			tint,
+			hitbox,
+			shadowCaster: computed(() => shadowCaster(graphicObj)),
+			flash: flashConfig
+		})))),
+		h(__ce_component$1, {
+			object,
+			position: "center",
+			graphicBounds
+		}),
+		h(__ce_component$1, {
+			object,
+			position: "right",
+			graphicBounds
+		}),
+		h(__ce_component$1, {
+			object,
+			position: "top",
+			graphicBounds
+		}),
+		loop(normalizedComponentsInFront, (compConfig) => h(Container, { dependencies: compConfig.dependencies }, h(compConfig.component, {
+			object,
+			...compConfig.props
+		}))),
+		loop(attachedGuis, (attachedGui) => cond(shouldDisplayAttachedGui, () => h(Container, null, h(attachedGui.component, {
+			...attachedGui.data(),
+			dependencies: attachedGui.dependencies,
+			object,
+			onFinish: (data) => {
+				onAttachedGuiFinish(attachedGui, data);
+			},
+			onInteraction: (name, data) => {
+				onAttachedGuiInteraction(attachedGui, name, data);
+			}
+		}))))
+	]);
+}
+var __ce_component = component;
+//#endregion
+export { __ce_component as default };
+
+//# sourceMappingURL=character.ce.js.map