@rpgjs/client 5.0.0-beta.11 → 5.0.0-beta.13

package/dist/RpgClientEngine.js

@@ -19,13 +19,72 @@ import __ce_component$3 from "./components/dynamics/bar.ce.js";
 import __ce_component$4 from "./components/dynamics/shape.ce.js";
 import __ce_component$5 from "./components/dynamics/image.ce.js";
 import { NotificationManager } from "./Gui/NotificationManager.js";
+import { normalizeRoomMapId } from "./utils/mapId.js";
 import { ProjectileManager } from "./Game/ProjectileManager.js";
+import { ClientVisualRegistry } from "./Game/ClientVisuals.js";
 import { createClientPointerContext } from "./services/pointerContext.js";
+import { RpgClientInteractions } from "./services/interactions.js";
+import { EventComponentResolverRegistry } from "./Game/EventComponentResolver.js";
+import { RpgClientBuiltinI18n } from "./i18n.js";
 import { Howl, bootstrapCanvas, signal, trigger } from "canvasengine";
-import { Direction, ModulesToken, PredictionController, Vector2, normalizeLightingState } from "@rpgjs/common";
+import { Direction, ModulesToken, PredictionController, Vector2, getOrCreateI18nService, normalizeLightingState } from "@rpgjs/common";
 import { BehaviorSubject, combineLatest, filter, lastValueFrom, switchMap, take } from "rxjs";
 import * as PIXI from "pixi.js";
 //#region src/RpgClientEngine.ts
+var DEFAULT_DASH_ADDITIONAL_SPEED = 8;
+var DEFAULT_DASH_DURATION_MS = 180;
+var DEFAULT_DASH_COOLDOWN_MS = 450;
+var isDashInput = (input) => typeof input === "object" && input !== null && input.type === "dash";
+var isMoveInput = (input) => typeof input === "object" && input !== null && input.type === "move";
+var resolveMoveDirection = (input) => {
+	if (isMoveInput(input)) return input.direction;
+	if (typeof input === "string" || typeof input === "number") return input;
+};
+var directionToVector = (direction) => {
+	switch (direction) {
+		case Direction.Left: return {
+			x: -1,
+			y: 0
+		};
+		case Direction.Right: return {
+			x: 1,
+			y: 0
+		};
+		case Direction.Up: return {
+			x: 0,
+			y: -1
+		};
+		case Direction.Down:
+		default: return {
+			x: 0,
+			y: 1
+		};
+	}
+};
+var vectorToDirection = (direction) => {
+	if (Math.abs(direction.x) > Math.abs(direction.y)) return direction.x < 0 ? Direction.Left : Direction.Right;
+	return direction.y < 0 ? Direction.Up : Direction.Down;
+};
+var normalizeDashInput = (input, fallbackDirection) => {
+	const rawDirection = input.direction ?? directionToVector(fallbackDirection);
+	const rawX = Number(rawDirection?.x ?? 0);
+	const rawY = Number(rawDirection?.y ?? 0);
+	const magnitude = Math.hypot(rawX, rawY);
+	if (!Number.isFinite(magnitude) || magnitude <= 0) return null;
+	const additionalSpeed = typeof input.additionalSpeed === "number" && Number.isFinite(input.additionalSpeed) ? Math.max(0, Math.min(input.additionalSpeed, 64)) : DEFAULT_DASH_ADDITIONAL_SPEED;
+	const duration = typeof input.duration === "number" && Number.isFinite(input.duration) ? Math.max(1, Math.min(input.duration, 1e3)) : DEFAULT_DASH_DURATION_MS;
+	const cooldown = typeof input.cooldown === "number" && Number.isFinite(input.cooldown) ? Math.max(0, Math.min(input.cooldown, 5e3)) : DEFAULT_DASH_COOLDOWN_MS;
+	return {
+		type: "dash",
+		direction: {
+			x: rawX / magnitude,
+			y: rawY / magnitude
+		},
+		additionalSpeed,
+		duration,
+		cooldown
+	};
+};
 var RpgClientEngine = class {
 	constructor(context) {
 		this.context = context;
@@ -34,14 +93,18 @@ var RpgClientEngine = class {
 		this.width = signal("100%");
 		this.height = signal("100%");
 		this.spritesheets = /* @__PURE__ */ new Map();
+		this.spritesheetPromises = /* @__PURE__ */ new Map();
 		this.sounds = /* @__PURE__ */ new Map();
 		this.componentAnimations = [];
+		this.clientVisuals = new ClientVisualRegistry();
 		this.pointer = createClientPointerContext();
+		this.interactions = new RpgClientInteractions(this);
 		this.particleSettings = { emitters: [] };
 		this.playerIdSignal = signal(null);
 		this.spriteComponentsBehind = signal([]);
 		this.spriteComponentsInFront = signal([]);
 		this.spriteComponents = /* @__PURE__ */ new Map();
+		this.eventComponentResolvers = new EventComponentResolverRegistry();
 		this.cameraFollowTargetId = signal(null);
 		this.mapShakeTrigger = trigger();
 		this.controlsReady = signal(void 0);
@@ -53,6 +116,7 @@ var RpgClientEngine = class {
 		this.lastClientPhysicsStepAt = 0;
 		this.frameOffset = 0;
 		this.latestServerTickAt = 0;
+		this.dashLockedUntil = 0;
 		this.rtt = 0;
 		this.pingInterval = null;
 		this.PING_INTERVAL_MS = 5e3;
@@ -66,6 +130,8 @@ var RpgClientEngine = class {
 		this.playersReceived$ = new BehaviorSubject(false);
 		this.eventsReceived$ = new BehaviorSubject(false);
 		this.sceneResetQueued = false;
+		this.mapTransitionInProgress = false;
+		this.socketListenersInitialized = false;
 		this.tickSubscriptions = [];
 		this.pendingSyncPackets = [];
 		this.notificationManager = new NotificationManager();
@@ -73,6 +139,8 @@ var RpgClientEngine = class {
 		this.guiService = inject(RpgGui);
 		this.loadMapService = inject(LoadMapToken);
 		this.hooks = inject(ModulesToken);
+		this.i18nService = getOrCreateI18nService(context);
+		this.i18nService.addMessages(RpgClientBuiltinI18n, "rpgjs-client", 0);
 		this.projectiles = new ProjectileManager(this.hooks, (projectile) => this.predictProjectileImpact(projectile));
 		this.globalConfig = inject(GlobalConfigToken);
 		if (!this.globalConfig) this.globalConfig = {};
@@ -96,6 +164,21 @@ var RpgClientEngine = class {
 		this.predictionEnabled = this.globalConfig?.prediction?.enabled !== false;
 		this.initializePredictionController();
 	}
+	setLocale(locale) {
+		this.locale = locale;
+	}
+	getLocale() {
+		return this.locale || this.i18nService.defaultLocale;
+	}
+	t(key, params) {
+		return this.i18nService.t(key, params, this.getLocale());
+	}
+	i18n() {
+		return {
+			locale: this.getLocale(),
+			t: (key, params) => this.t(key, params)
+		};
+	}
 	/**
 	* Assigns a CanvasEngine KeyboardControls instance to the dependency injection context
 	* 
@@ -160,7 +243,6 @@ var RpgClientEngine = class {
 		this.renderer = app.renderer;
 		this.setupPointerTracking();
 		this.tick = canvasElement?.propObservables?.context["tick"].observable;
-		this.flushPendingSyncPackets();
 		const inputCheckSubscription = this.tick.subscribe(() => {
 			if (Date.now() - this.lastInputTime > 100) {
 				const player = this.getCurrentPlayer();
@@ -171,6 +253,7 @@ var RpgClientEngine = class {
 		this.tickSubscriptions.push(inputCheckSubscription);
 		this.hooks.callHooks("client-spritesheets-load", this).subscribe();
 		this.hooks.callHooks("client-spritesheetResolver-load", this).subscribe();
+		this.flushPendingSyncPackets();
 		this.hooks.callHooks("client-sounds-load", this).subscribe();
 		this.hooks.callHooks("client-soundResolver-load", this).subscribe();
 		RpgSound.init(this);
@@ -178,7 +261,9 @@ var RpgClientEngine = class {
 		this.hooks.callHooks("client-gui-load", this).subscribe();
 		this.hooks.callHooks("client-particles-load", this).subscribe();
 		this.hooks.callHooks("client-componentAnimations-load", this).subscribe();
+		this.hooks.callHooks("client-clientVisuals-load", this).subscribe();
 		this.hooks.callHooks("client-projectiles-load", this).subscribe();
+		this.hooks.callHooks("client-interactions-load", this).subscribe();
 		this.hooks.callHooks("client-sprite-load", this).subscribe();
 		await lastValueFrom(this.hooks.callHooks("client-engine-onStart", this));
 		this.resizeHandler = () => {
@@ -210,7 +295,7 @@ var RpgClientEngine = class {
 		const canvas = renderer?.canvas ?? renderer?.view ?? this.canvasApp?.canvas;
 		if (!canvas || typeof canvas.addEventListener !== "function") return;
 		this.pointerCanvas = canvas;
-		this.pointerMoveHandler = (event) => {
+		const updatePointer = (event) => {
 			const rect = canvas.getBoundingClientRect();
 			const screen = {
 				x: event.clientX - rect.left,
@@ -233,11 +318,59 @@ var RpgClientEngine = class {
 			}
 			this.pointer.update(screen, world);
 		};
+		this.pointerMoveHandler = (event) => {
+			updatePointer(event);
+			this.interactions.handlePointerMove(event);
+		};
+		this.pointerUpHandler = (event) => {
+			updatePointer(event);
+			this.interactions.handlePointerUp(event);
+		};
+		this.pointerCancelHandler = (event) => {
+			updatePointer(event);
+			this.interactions.cancelDrag(event);
+		};
 		canvas.addEventListener("pointermove", this.pointerMoveHandler);
 		canvas.addEventListener("pointerdown", this.pointerMoveHandler);
+		canvas.addEventListener("pointerup", this.pointerUpHandler);
+		canvas.addEventListener("pointercancel", this.pointerCancelHandler);
+		canvas.addEventListener("pointerleave", this.pointerCancelHandler);
+	}
+	updatePointerFromInteractionEvent(event) {
+		const global = event?.global ?? event?.data?.global;
+		if (!global) {
+			this.pointer.updateFromEvent(event);
+			return;
+		}
+		const screen = {
+			x: Number(global.x),
+			y: Number(global.y)
+		};
+		if (!Number.isFinite(screen.x) || !Number.isFinite(screen.y)) {
+			this.pointer.updateFromEvent(event);
+			return;
+		}
+		const viewport = this.findViewportInstance();
+		if (viewport && typeof viewport.toWorld === "function") {
+			const point = viewport.toWorld(screen.x, screen.y);
+			this.pointer.update(screen, {
+				x: Number(point.x),
+				y: Number(point.y)
+			});
+			return;
+		}
+		this.pointer.update(screen);
 	}
 	findViewportInstance() {
-		return (this.canvasApp?.stage?.children ?? []).find((child) => typeof child?.toWorld === "function" || child?.constructor?.name === "Viewport");
+		const find = (node) => {
+			if (!node) return void 0;
+			if (typeof node?.toWorld === "function" || node?.constructor?.name === "Viewport") return node;
+			for (const child of node.children ?? []) {
+				const viewport = find(child);
+				if (viewport) return viewport;
+			}
+		};
+		return find(this.canvasApp?.stage);
 	}
 	prepareSyncPayload(data) {
 		const payload = { ...data ?? {} };
@@ -271,6 +404,8 @@ var RpgClientEngine = class {
 		};
 	}
 	initListeners() {
+		if (this.socketListenersInitialized) return;
+		this.socketListenersInitialized = true;
 		this.webSocket.on("sync", (data) => {
 			if (!this.tick) {
 				this.pendingSyncPackets.push(data);
@@ -288,12 +423,8 @@ var RpgClientEngine = class {
 			console.debug(`[Ping/Pong] RTT: ${this.rtt}ms, ServerTick: ${data.serverTick}, FrameOffset: ${this.frameOffset}`);
 		});
 		this.webSocket.on("changeMap", (data) => {
-			this.sceneResetQueued = true;
-			this.sceneMap.weatherState.set(null);
-			this.sceneMap.lightingState.set(null);
-			this.sceneMap.clearLightSpots();
-			this.projectiles.clear();
-			this.cameraFollowTargetId.set(null);
+			const nextMapId = typeof data?.mapId === "string" ? data.mapId : void 0;
+			this.beginMapTransfer(nextMapId);
 			const transferToken = typeof data?.transferToken === "string" ? data.transferToken : void 0;
 			this.loadScene(data.mapId, transferToken);
 		});
@@ -303,19 +434,27 @@ var RpgClientEngine = class {
 			const player = object ? this.sceneMap.getObjectById(object) : void 0;
 			this.getComponentAnimation(id).displayEffect(params, player || position);
 		});
+		this.webSocket.on("clientVisual", (data) => {
+			this.playClientVisual(data);
+		});
 		this.webSocket.on("projectile:spawnBatch", (data) => {
+			if (!this.shouldProcessProjectilePacket(data)) return;
 			this.projectiles.spawnBatch(data?.projectiles ?? [], {
+				mapId: data?.mapId,
 				currentServerTick: this.estimateServerTick(),
 				tickDurationMs: this.getPhysicsTickDurationMs()
 			});
 		});
 		this.webSocket.on("projectile:impactBatch", (data) => {
-			this.projectiles.impactBatch(data?.impacts ?? []);
+			if (!this.shouldProcessProjectilePacket(data)) return;
+			this.projectiles.impactBatch(data?.impacts ?? [], { mapId: data?.mapId });
 		});
 		this.webSocket.on("projectile:destroyBatch", (data) => {
-			this.projectiles.destroyBatch(data?.projectiles ?? []);
+			if (!this.shouldProcessProjectilePacket(data)) return;
+			this.projectiles.destroyBatch(data?.projectiles ?? [], { mapId: data?.mapId });
 		});
-		this.webSocket.on("projectile:clear", () => {
+		this.webSocket.on("projectile:clear", (data) => {
+			if (!this.shouldProcessProjectilePacket(data)) return;
 			this.projectiles.clear();
 		});
 		this.webSocket.on("notification", (data) => {
@@ -408,6 +547,31 @@ var RpgClientEngine = class {
 			this.callConnectError(error);
 		});
 	}
+	beginMapTransfer(nextMapId) {
+		this.mapTransitionInProgress = true;
+		this.currentMapRoomId = nextMapId;
+		this.sceneResetQueued = false;
+		this.clearClientPredictionStates();
+		this.sceneMap.weatherState.set(null);
+		this.sceneMap.lightingState.set(null);
+		this.sceneMap.clearLightSpots();
+		this.clearComponentAnimations();
+		this.projectiles.setMapId(nextMapId);
+		this.cameraFollowTargetId.set(null);
+		this.sceneMap.reset();
+		this.sceneMap.loadPhysic();
+	}
+	clearComponentAnimations() {
+		this.componentAnimations.forEach((componentAnimation) => {
+			componentAnimation.instance?.clear?.();
+		});
+	}
+	shouldProcessProjectilePacket(data) {
+		if (this.mapTransitionInProgress) return false;
+		const packetMapId = normalizeRoomMapId(typeof data?.mapId === "string" ? data.mapId : void 0);
+		const currentMapId = normalizeRoomMapId(this.currentMapRoomId);
+		return !packetMapId || !currentMapId || packetMapId === currentMapId;
+	}
 	async callConnectError(error) {
 		await lastValueFrom(this.hooks.callHooks("client-engine-onConnectError", this, error, this.socket));
 	}
@@ -522,12 +686,9 @@ var RpgClientEngine = class {
 			query: transferToken ? { transferToken } : void 0
 		});
 		try {
-			await this.webSocket.reconnect(() => {
-				inject(SaveClientService).initialize();
-				this.initListeners();
-				this.guiService._initialize();
-			});
+			await this.webSocket.reconnect();
 		} catch (error) {
+			this.mapTransitionInProgress = false;
 			this.stopPingPong();
 			await this.callConnectError(error);
 			throw error;
@@ -539,6 +700,8 @@ var RpgClientEngine = class {
 		if (players && Object.keys(players).length > 0) this.playersReceived$.next(true);
 		if (this.sceneMap.events() !== void 0) this.eventsReceived$.next(true);
 		this.mapLoadCompleted$.next(true);
+		this.currentMapRoomId = mapId;
+		this.mapTransitionInProgress = false;
 		this.sceneMap.configureClientPrediction(this.predictionEnabled);
 		this.sceneMap.loadPhysic();
 	}
@@ -599,12 +762,20 @@ var RpgClientEngine = class {
 	getSpriteSheet(id) {
 		if (this.spritesheets.has(id)) return this.spritesheets.get(id);
 		if (this.spritesheetResolver) {
+			if (this.spritesheetPromises.has(id)) return this.spritesheetPromises.get(id);
 			const result = this.spritesheetResolver(id);
-			if (result instanceof Promise) return result.then((spritesheet) => {
-				if (spritesheet) this.spritesheets.set(id, spritesheet);
-				return spritesheet;
-			});
-			else {
+			if (result instanceof Promise) {
+				const promise = result.then((spritesheet) => {
+					if (spritesheet) this.spritesheets.set(id, spritesheet);
+					this.spritesheetPromises.delete(id);
+					return spritesheet;
+				}).catch((error) => {
+					this.spritesheetPromises.delete(id);
+					throw error;
+				});
+				this.spritesheetPromises.set(id, promise);
+				return promise;
+			} else {
 				if (result) this.spritesheets.set(id, result);
 				return result;
 			}
@@ -960,6 +1131,27 @@ var RpgClientEngine = class {
 	getSpriteComponent(id) {
 		return this.spriteComponents.get(id);
 	}
+	/**
+	* Register a custom event component resolver.
+	*
+	* The last resolver returning a component wins. This lets later modules
+	* override earlier defaults without replacing the whole map scene.
+	*
+	* @param resolver - Function receiving the synced event object
+	* @returns The registered resolver
+	*/
+	addEventComponentResolver(resolver) {
+		return this.eventComponentResolvers.add(resolver);
+	}
+	/**
+	* Resolve the custom CanvasEngine component for an event, if any.
+	*
+	* @param event - Synced client event object
+	* @returns The component/config returned by the last matching resolver
+	*/
+	resolveEventComponent(event) {
+		return this.eventComponentResolvers.resolve(event);
+	}
 	registerProjectileComponent(type, component) {
 		return this.projectiles.register(type, component);
 	}
@@ -967,6 +1159,39 @@ var RpgClientEngine = class {
 		return this.projectiles.get(type);
 	}
 	/**
+	* Register a named client visual macro.
+	*
+	* Client visuals are small client-side functions that group existing visual
+	* primitives such as flash, sound, component animations, sprite animation, or
+	* map shake. The server sends only the visual name and a serializable payload.
+	*
+	* @param name - Stable visual name sent by the server
+	* @param handler - Client-side visual handler
+	* @returns The registered handler
+	*/
+	registerClientVisual(name, handler) {
+		return this.clientVisuals.register(name, handler);
+	}
+	/**
+	* Register several named client visual macros.
+	*
+	* @param visuals - Map of visual names to client-side handlers
+	*/
+	registerClientVisuals(visuals) {
+		this.clientVisuals.registerMany(visuals);
+	}
+	/**
+	* Play a registered client visual locally.
+	*
+	* This is also used by the websocket listener when the server calls
+	* `player.clientVisual()` or `map.clientVisual()`.
+	*
+	* @param packet - Visual name and serializable payload
+	*/
+	playClientVisual(packet) {
+		return this.clientVisuals.play(packet, this);
+	}
+	/**
 	* Add a component animation to the engine
 	* 
 	* Component animations are temporary visual effects that can be displayed
@@ -1071,10 +1296,17 @@ var RpgClientEngine = class {
 			return;
 		}
 		const timestamp = Date.now();
+		const movementInput = isDashInput(input) ? normalizeDashInput(input, currentPlayer?.direction?.()) : input;
+		if (!movementInput) return;
+		if (isDashInput(movementInput)) {
+			const cooldown = movementInput.cooldown ?? DEFAULT_DASH_COOLDOWN_MS;
+			if (timestamp < this.dashLockedUntil) return;
+			this.dashLockedUntil = timestamp + cooldown;
+		}
 		let frame;
 		let tick;
 		if (this.predictionEnabled && this.prediction) {
-			const meta = this.prediction.recordInput(input, timestamp);
+			const meta = this.prediction.recordInput(movementInput, timestamp);
 			frame = meta.frame;
 			tick = meta.tick;
 		} else {
@@ -1083,20 +1315,25 @@ var RpgClientEngine = class {
 		}
 		this.inputFrameCounter = frame;
 		this.hooks.callHooks("client-engine-onInput", this, {
-			input,
+			input: movementInput,
 			playerId: this.playerId
 		}).subscribe();
 		const bodyReady = this.ensureCurrentPlayerBody();
 		if (currentPlayer && bodyReady) {
-			currentPlayer.changeDirection(input);
-			this.sceneMap.moveBody(currentPlayer, input);
+			this.applyPredictedMovementInput(currentPlayer, movementInput);
 			if (this.predictionEnabled && this.prediction) {
 				this.pendingPredictionFrames.push(frame);
 				if (this.pendingPredictionFrames.length > 240) this.pendingPredictionFrames = this.pendingPredictionFrames.slice(-240);
 			}
 		}
-		this.emitMovePacket(input, frame, tick, timestamp, true);
-		this.lastInputTime = Date.now();
+		this.emitMovePacket(movementInput, frame, tick, timestamp, true);
+		this.lastInputTime = isDashInput(movementInput) ? Date.now() + (movementInput.duration ?? DEFAULT_DASH_DURATION_MS) : Date.now();
+	}
+	async processDash(input = {}) {
+		const currentPlayer = this.sceneMap.getCurrentPlayer();
+		const dashInput = normalizeDashInput(input, typeof currentPlayer?.direction === "function" ? currentPlayer.direction() : currentPlayer?.direction);
+		if (!dashInput) return;
+		await this.processInput({ input: dashInput });
 	}
 	processAction(action, data) {
 		if (this.stopProcessingInput) return;
@@ -1123,6 +1360,9 @@ var RpgClientEngine = class {
 	get scene() {
 		return this.sceneMap;
 	}
+	getObjectById(id) {
+		return this.sceneMap?.getObjectById(id);
+	}
 	getPhysicsTick() {
 		return this.sceneMap?.getTick?.() ?? 0;
 	}
@@ -1202,7 +1442,7 @@ var RpgClientEngine = class {
 				input: entry.direction,
 				x: state.x,
 				y: state.y,
-				direction: state.direction ?? entry.direction
+				direction: state.direction ?? resolveMoveDirection(entry.direction)
 			});
 		}
 		if (trajectory.length > this.MAX_MOVE_TRAJECTORY_POINTS) return trajectory.slice(-this.MAX_MOVE_TRAJECTORY_POINTS);
@@ -1237,6 +1477,17 @@ var RpgClientEngine = class {
 		if (now - this.lastMovePathSentAt < this.MOVE_PATH_RESEND_INTERVAL_MS) return;
 		this.emitMovePacket(latest.direction, latest.frame, latest.tick, now, false);
 	}
+	applyPredictedMovementInput(player, input) {
+		if (isDashInput(input)) {
+			const direction = vectorToDirection(input.direction);
+			player.changeDirection(direction);
+			return Boolean(this.sceneMap.dashBody?.(player, input));
+		}
+		const direction = resolveMoveDirection(input);
+		if (!direction) return false;
+		player.changeDirection(direction);
+		return Boolean(this.sceneMap.moveBody?.(player, direction));
+	}
 	getLocalPlayerState() {
 		const currentPlayer = this.sceneMap?.getCurrentPlayer();
 		if (!currentPlayer) return {
@@ -1462,7 +1713,7 @@ var RpgClientEngine = class {
 		const replayInputs = pendingInputs.slice(-600);
 		for (const entry of replayInputs) {
 			if (!entry?.direction) continue;
-			this.sceneMap.moveBody(player, entry.direction);
+			this.applyPredictedMovementInput(player, entry.direction);
 			this.sceneMap.stepPredictionTick();
 			this.prediction?.attachPredictedState(entry.frame, this.getLocalPlayerState());
 		}
@@ -1531,7 +1782,14 @@ var RpgClientEngine = class {
 			if (this.pointerMoveHandler && this.pointerCanvas) {
 				this.pointerCanvas.removeEventListener("pointermove", this.pointerMoveHandler);
 				this.pointerCanvas.removeEventListener("pointerdown", this.pointerMoveHandler);
+				if (this.pointerUpHandler) this.pointerCanvas.removeEventListener("pointerup", this.pointerUpHandler);
+				if (this.pointerCancelHandler) {
+					this.pointerCanvas.removeEventListener("pointercancel", this.pointerCancelHandler);
+					this.pointerCanvas.removeEventListener("pointerleave", this.pointerCancelHandler);
+				}
 				this.pointerMoveHandler = void 0;
+				this.pointerUpHandler = void 0;
+				this.pointerCancelHandler = void 0;
 				this.pointerCanvas = void 0;
 			}
 			const rendererStillExists = this.renderer && typeof this.renderer.destroy === "function";
@@ -1565,6 +1823,7 @@ var RpgClientEngine = class {
 			this.cameraFollowTargetId.set(null);
 			this.spriteComponentsBehind.set([]);
 			this.spriteComponentsInFront.set([]);
+			this.eventComponentResolvers.clear();
 			this.spritesheets.clear();
 			this.sounds.clear();
 			this.componentAnimations = [];