@rpgjs/client 5.0.0-beta.10 → 5.0.0-beta.12

package/src/RpgClientEngine.ts

@@ -1,11 +1,14 @@
 import Canvas from "./components/scenes/canvas.ce";
+import BuiltinSceneMap from "./components/scenes/draw-map.ce";
 import { inject } from './core/inject'
 import { signal, bootstrapCanvas, Howl, trigger, type Trigger } from "canvasengine";
 import { AbstractWebsocket, WebSocketToken } from "./services/AbstractSocket";
 import { LoadMapService, LoadMapToken } from "./services/loadMap";
 import { RpgSound } from "./Sound";
 import { RpgResource } from "./Resource";
-import { Hooks, ModulesToken, Direction, normalizeLightingState } from "@rpgjs/common";
+import { Hooks, ModulesToken, Direction, normalizeLightingState, Vector2 } from "@rpgjs/common";
+import type { EventComponentConfig } from "./RpgClient";
+import type { RpgClientEvent } from "./Game/Event";
 import { load } from "@signe/sync";
 import { RpgClientMap } from "./Game/Map"
 import { RpgGui } from "./Gui/Gui";
@@ -22,10 +25,18 @@ import {
   PredictionController,
   type PredictionHistoryEntry,
   type PredictionState,
+  type RpgActionInput,
+  type RpgActionName,
 } from "@rpgjs/common";
 import { NotificationManager } from "./Gui/NotificationManager";
 import { SaveClientService } from "./services/save";
 import { getCanMoveValue } from "./utils/readPropValue";
+import { ProjectileManager, type ClientProjectileImpact, type ClientProjectileSpawn } from "./Game/ProjectileManager";
+import { ClientVisualRegistry, type ClientVisualHandler, type ClientVisualMap, type ClientVisualPacket } from "./Game/ClientVisuals";
+import { normalizeActionInput } from "./services/actionInput";
+import { createClientPointerContext, type ClientPointerContext } from "./services/pointerContext";
+import { normalizeRoomMapId } from "./utils/mapId";
+import { EventComponentResolverRegistry, type EventComponentResolver } from "./Game/EventComponentResolver";
 
 interface MovementTrajectoryPoint {
   frame: number;
@@ -57,12 +68,16 @@ export class RpgClientEngine<T = any> {
   private selector: HTMLElement;
   public globalConfig: T;
   public sceneComponent: any;
+  public sceneMapComponent: any = BuiltinSceneMap;
   stopProcessingInput = false;
   width = signal("100%");
   height = signal("100%");
   spritesheets: Map<string | number, any> = new Map();
   sounds: Map<string, any> = new Map();
   componentAnimations: any[] = [];
+  clientVisuals = new ClientVisualRegistry();
+  projectiles: ProjectileManager;
+  pointer: ClientPointerContext = createClientPointerContext();
   private spritesheetResolver?: (id: string | number) => any | Promise<any>;
   private soundResolver?: (id: string) => any | Promise<any>;
   particleSettings: {
@@ -78,6 +93,7 @@ export class RpgClientEngine<T = any> {
   spriteComponentsBehind = signal<any[]>([]);
   spriteComponentsInFront = signal<any[]>([]);
   spriteComponents: Map<string, any> = new Map();
+  private eventComponentResolvers = new EventComponentResolverRegistry();
   /** ID of the sprite that the camera should follow. null means follow the current player */
   cameraFollowTargetId = signal<string | null>(null);
   /** Trigger for map shake animation */
@@ -93,6 +109,8 @@ export class RpgClientEngine<T = any> {
   private pendingPredictionFrames: number[] = [];
   private lastClientPhysicsStepAt = 0;
   private frameOffset = 0;
+  private latestServerTick?: number;
+  private latestServerTickAt = 0;
   // Ping/Pong for RTT measurement
   private rtt: number = 0; // Round-trip time in ms
   private pingInterval: any = null;
@@ -109,10 +127,16 @@ export class RpgClientEngine<T = any> {
   private eventsReceived$ = new BehaviorSubject<boolean>(false);
   private onAfterLoadingSubscription?: any;
   private sceneResetQueued = false;
+  private mapTransitionInProgress = false;
+  private currentMapRoomId?: string;
+  private socketListenersInitialized = false;
   
   // Store subscriptions and event listeners for cleanup
   private tickSubscriptions: any[] = [];
   private resizeHandler?: () => void;
+  private pointerMoveHandler?: (event: PointerEvent) => void;
+  private pointerCanvas?: HTMLCanvasElement;
+  private pendingSyncPackets: any[] = [];
   private notificationManager: NotificationManager = new NotificationManager();
 
   constructor(public context) {
@@ -120,6 +144,10 @@ export class RpgClientEngine<T = any> {
     this.guiService = inject(RpgGui);
     this.loadMapService = inject(LoadMapToken);
     this.hooks = inject<Hooks>(ModulesToken);
+    this.projectiles = new ProjectileManager(
+      this.hooks,
+      (projectile) => this.predictProjectileImpact(projectile),
+    );
     this.globalConfig = inject(GlobalConfigToken)
 
     if (!this.globalConfig) {
@@ -197,6 +225,22 @@ export class RpgClientEngine<T = any> {
     this.sceneMap = new RpgClientMap()
     this.sceneMap.configureClientPrediction(this.predictionEnabled);
     this.sceneMap.loadPhysic();
+    this.resolveSceneMapComponent();
+
+    const saveClient = inject(SaveClientService);
+    saveClient.initialize();
+    this.initListeners();
+    this.guiService._initialize();
+
+    try {
+      await this.webSocket.connection();
+    }
+    catch (error) {
+      this.stopPingPong();
+      await this.callConnectError(error);
+      throw error;
+    }
+
     this.selector = document.body.querySelector("#rpg") as HTMLElement;
 
     const bootstrapOptions = (this.globalConfig as any)?.bootstrapCanvasOptions;
@@ -207,8 +251,10 @@ export class RpgClientEngine<T = any> {
     );
     this.canvasApp = app;
     this.canvasElement = canvasElement;
-    this.renderer = app.renderer as PIXI.Renderer;
+    this.renderer = app.renderer as unknown as PIXI.Renderer;
+    this.setupPointerTracking();
     this.tick = canvasElement?.propObservables?.context['tick'].observable
+    this.flushPendingSyncPackets();
 
     const inputCheckSubscription = this.tick.subscribe(() => {
       if (Date.now() - this.lastInputTime > 100) {
@@ -224,12 +270,14 @@ export class RpgClientEngine<T = any> {
     this.hooks.callHooks("client-spritesheetResolver-load", this).subscribe();
     this.hooks.callHooks("client-sounds-load", this).subscribe();
     this.hooks.callHooks("client-soundResolver-load", this).subscribe();
-    
+
     RpgSound.init(this);
     RpgResource.init(this);
     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-sprite-load", this).subscribe();
 
     await lastValueFrom(this.hooks.callHooks("client-engine-onStart", this));
@@ -242,6 +290,7 @@ export class RpgClientEngine<T = any> {
 
     const tickSubscription = this.tick.subscribe((tick) => {
       this.stepClientPhysicsTick();
+      this.projectiles.step();
       this.flushPendingPredictedStates();
       this.flushPendingMovePath();
       this.hooks.callHooks("client-engine-onStep", this, tick).subscribe();
@@ -255,13 +304,56 @@ export class RpgClientEngine<T = any> {
     });
     this.tickSubscriptions.push(tickSubscription);
 
-    await this.webSocket.connection(() => {
-      const saveClient = inject(SaveClientService);
-      saveClient.initialize();
-      this.initListeners()
-      this.guiService._initialize()
-      this.startPingPong();
-    });
+    this.startPingPong();
+  }
+
+  private resolveSceneMapComponent() {
+    const components = this.hooks.getHookFunctions("client-sceneMap-component");
+    const component = components[components.length - 1];
+    if (component) {
+      this.sceneMapComponent = component;
+    }
+  }
+
+  private setupPointerTracking() {
+    const renderer = this.renderer as any;
+    const canvas = renderer?.canvas ?? renderer?.view ?? (this.canvasApp as any)?.canvas;
+
+    if (!canvas || typeof canvas.addEventListener !== "function") {
+      return;
+    }
+
+    this.pointerCanvas = canvas;
+    this.pointerMoveHandler = (event: PointerEvent) => {
+      const rect = canvas.getBoundingClientRect();
+      const screen = {
+        x: event.clientX - rect.left,
+        y: event.clientY - rect.top,
+      };
+      const viewport = this.findViewportInstance();
+      let world = screen;
+
+      if (viewport && typeof viewport.toWorld === "function") {
+        const point = viewport.toWorld(screen.x, screen.y);
+        world = { x: Number(point.x), y: Number(point.y) };
+      } else if (viewport && typeof viewport.toLocal === "function") {
+        const point = viewport.toLocal(screen);
+        world = { x: Number(point.x), y: Number(point.y) };
+      }
+
+      this.pointer.update(screen, world);
+    };
+
+    canvas.addEventListener("pointermove", this.pointerMoveHandler);
+    canvas.addEventListener("pointerdown", this.pointerMoveHandler);
+  }
+
+  private findViewportInstance(): any {
+    const children = (this.canvasApp as any)?.stage?.children ?? [];
+    return children.find((child: any) => (
+      typeof child?.toWorld === "function"
+      || child?.constructor?.name === "Viewport"
+    ));
   }
 
   private prepareSyncPayload(data: any): any {
@@ -311,52 +403,15 @@ export class RpgClientEngine<T = any> {
   }
 
   private initListeners() {
-    this.webSocket.on("sync", (data) => {
-      if (data.pId) {
-        this.playerIdSignal.set(data.pId);
-        // Signal that player ID was received
-        this.playerIdReceived$.next(true);
-      }
+    if (this.socketListenersInitialized) return;
+    this.socketListenersInitialized = true;
 
-      if (this.sceneResetQueued) {
-        this.sceneMap.reset();
-        this.sceneMap.loadPhysic();
-        this.sceneResetQueued = false;
-      }
-
-      // Apply client-side prediction filtering and server reconciliation
-      this.hooks.callHooks("client-sceneMap-onChanges", this.sceneMap, { partial: data }).subscribe();
-
-      const ack = data?.ack;
-      const normalizedAck =
-        ack && typeof ack.frame === "number"
-          ? this.normalizeAckWithSyncState(ack, data)
-          : undefined;
-      const payload = this.prepareSyncPayload(data);
-      load(this.sceneMap, payload, true);
-
-      if (normalizedAck) {
-        this.applyServerAck(normalizedAck);
-      }
-
-      for (const playerId in payload.players ?? {}) {
-        const player = payload.players[playerId]
-        if (!player._param) continue
-        for (const param in player._param) {
-         this.sceneMap.players()[playerId]._param()[param] = player._param[param]
-        }
-      }
-      
-      // Check if players and events are present in sync data
-      const players = payload.players || this.sceneMap.players();
-      if (players && Object.keys(players).length > 0) {
-        this.playersReceived$.next(true);
-      }
-      
-      const events = payload.events || this.sceneMap.events();
-      if (events !== undefined) {
-        this.eventsReceived$.next(true);
+    this.webSocket.on("sync", (data) => {
+      if (!this.tick) {
+        this.pendingSyncPackets.push(data);
+        return;
       }
+      this.applySyncPacket(data);
     });
 
     // Handle pong responses for RTT measurement
@@ -368,6 +423,7 @@ export class RpgClientEngine<T = any> {
       // This helps us estimate which server tick corresponds to each client input frame
       const estimatedTicksInFlight = Math.floor(this.rtt / 2 / (1000 / 60)); // Estimate ticks during half RTT
       const estimatedServerTickNow = data.serverTick + estimatedTicksInFlight;
+      this.updateServerTickEstimate(estimatedServerTickNow, now);
 
       // Update frame offset (only if we have inputs to calibrate with)
       if (this.inputFrameCounter > 0) {
@@ -378,10 +434,8 @@ export class RpgClientEngine<T = any> {
     });
 
     this.webSocket.on("changeMap", (data) => {
-      this.sceneResetQueued = true;
-      this.sceneMap.clearLightSpots();
-      // Reset camera follow to default (follow current player) when changing maps
-      this.cameraFollowTargetId.set(null);
+      const nextMapId = typeof data?.mapId === "string" ? data.mapId : undefined;
+      this.beginMapTransfer(nextMapId);
       const transferToken = typeof data?.transferToken === "string" ? data.transferToken : undefined;
       this.loadScene(data.mapId, transferToken);
     });
@@ -395,6 +449,38 @@ export class RpgClientEngine<T = any> {
       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) => {
+      if (!this.shouldProcessProjectilePacket(data)) return;
+      this.projectiles.impactBatch(data?.impacts ?? [], {
+        mapId: data?.mapId,
+      });
+    });
+
+    this.webSocket.on("projectile:destroyBatch", (data) => {
+      if (!this.shouldProcessProjectilePacket(data)) return;
+      this.projectiles.destroyBatch(data?.projectiles ?? [], {
+        mapId: data?.mapId,
+      });
+    });
+
+    this.webSocket.on("projectile:clear", (data) => {
+      if (!this.shouldProcessProjectilePacket(data)) return;
+      this.projectiles.clear();
+    });
+
     this.webSocket.on("notification", (data) => {
       this.notificationManager.add(data);
     });
@@ -505,10 +591,102 @@ export class RpgClientEngine<T = any> {
     })
 
     this.webSocket.on('error', (error) => {
-      this.hooks.callHooks("client-engine-onConnectError", this, error, this.socket).subscribe();
+      void this.callConnectError(error);
     })
   }
 
+  private beginMapTransfer(nextMapId?: string) {
+    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();
+  }
+
+  private clearComponentAnimations() {
+    this.componentAnimations.forEach((componentAnimation) => {
+      componentAnimation.instance?.clear?.();
+    });
+  }
+
+  private shouldProcessProjectilePacket(data: any): boolean {
+    if (this.mapTransitionInProgress) return false;
+    const packetMapId = normalizeRoomMapId(
+      typeof data?.mapId === "string" ? data.mapId : undefined,
+    );
+    const currentMapId = normalizeRoomMapId(this.currentMapRoomId);
+    return !packetMapId || !currentMapId || packetMapId === currentMapId;
+  }
+
+  private async callConnectError(error: any) {
+    await lastValueFrom(this.hooks.callHooks("client-engine-onConnectError", this, error, this.socket));
+  }
+
+  private flushPendingSyncPackets() {
+    const packets = this.pendingSyncPackets;
+    this.pendingSyncPackets = [];
+    packets.forEach((packet) => this.applySyncPacket(packet));
+  }
+
+  private applySyncPacket(data: any) {
+    if (data.pId) {
+      this.playerIdSignal.set(data.pId);
+      // Signal that player ID was received
+      this.playerIdReceived$.next(true);
+    }
+
+    if (this.sceneResetQueued) {
+      const weatherState = this.sceneMap.weatherState();
+      const lightingState = this.sceneMap.lightingState();
+      this.sceneMap.reset();
+      this.sceneMap.weatherState.set(weatherState);
+      this.sceneMap.lightingState.set(lightingState);
+      this.sceneMap.loadPhysic();
+      this.sceneResetQueued = false;
+    }
+
+    // Apply client-side prediction filtering and server reconciliation
+    this.hooks.callHooks("client-sceneMap-onChanges", this.sceneMap, { partial: data }).subscribe();
+
+    const ack = data?.ack;
+    const normalizedAck =
+      ack && typeof ack.frame === "number"
+        ? this.normalizeAckWithSyncState(ack, data)
+        : undefined;
+    const payload = this.prepareSyncPayload(data);
+    load(this.sceneMap, payload, true);
+
+    if (normalizedAck) {
+      this.applyServerAck(normalizedAck);
+    }
+
+    for (const playerId in payload.players ?? {}) {
+      const player = payload.players[playerId]
+      if (!player._param) continue
+      for (const param in player._param) {
+       this.sceneMap.players()[playerId]._param()[param] = player._param[param]
+      }
+    }
+
+    // Check if players and events are present in sync data
+    const players = payload.players || this.sceneMap.players();
+    if (players && Object.keys(players).length > 0) {
+      this.playersReceived$.next(true);
+    }
+
+    const events = payload.events || this.sceneMap.events();
+    if (events !== undefined) {
+      this.eventsReceived$.next(true);
+    }
+  }
+
   /**
    * Start periodic ping/pong for client-server synchronization
    * 
@@ -605,12 +783,15 @@ export class RpgClientEngine<T = any> {
       room: mapId,
       query: transferToken ? { transferToken } : undefined,
     })
-    await this.webSocket.reconnect(() => {
-      const saveClient = inject(SaveClientService);
-      saveClient.initialize();
-      this.initListeners()
-      this.guiService._initialize()
-    })
+    try {
+      await this.webSocket.reconnect()
+    }
+    catch (error) {
+      this.mapTransitionInProgress = false;
+      this.stopPingPong();
+      await this.callConnectError(error);
+      throw error;
+    }
     const res = await this.loadMapService.load(mapId)
     this.sceneMap.data.set(res)
     
@@ -632,6 +813,8 @@ export class RpgClientEngine<T = any> {
     
     // Signal that map loading is completed (this should be last to ensure other checks are done)
     this.mapLoadCompleted$.next(true);
+    this.currentMapRoomId = mapId;
+    this.mapTransitionInProgress = false;
     this.sceneMap.configureClientPrediction(this.predictionEnabled);
     this.sceneMap.loadPhysic()
   }
@@ -1157,6 +1340,73 @@ export class RpgClientEngine<T = any> {
     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: EventComponentResolver) {
+    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: RpgClientEvent): EventComponentConfig | null {
+    return this.eventComponentResolvers.resolve(event);
+  }
+
+  registerProjectileComponent(type: string, component: any) {
+    return this.projectiles.register(type, component);
+  }
+
+  getProjectileComponent(type: string) {
+    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: string, handler: ClientVisualHandler) {
+    return this.clientVisuals.register(name, handler);
+  }
+
+  /**
+   * Register several named client visual macros.
+   *
+   * @param visuals - Map of visual names to client-side handlers
+   */
+  registerClientVisuals(visuals: ClientVisualMap) {
+    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: ClientVisualPacket) {
+    return this.clientVisuals.play(packet, this);
+  }
+
   /**
    * Add a component animation to the engine
    * 
@@ -1307,7 +1557,9 @@ export class RpgClientEngine<T = any> {
     this.lastInputTime = Date.now();
   }
 
-  processAction({ action }: { action: number }) {
+  processAction(action: RpgActionName, data?: any): void;
+  processAction(action: RpgActionInput): void;
+  processAction(action: RpgActionName | RpgActionInput, data?: any): void {
     if (this.stopProcessingInput) return;
     const currentPlayer = this.sceneMap.getCurrentPlayer() as any;
     const canMove =
@@ -1315,8 +1567,15 @@ export class RpgClientEngine<T = any> {
       getCanMoveValue(currentPlayer);
     if (!canMove) return;
 
-    this.hooks.callHooks("client-engine-onInput", this, { input: 'action', playerId: this.playerId }).subscribe();
-    this.webSocket.emit('action', { action })
+    const payload = normalizeActionInput(action as any, data);
+
+    this.hooks.callHooks("client-engine-onInput", this, {
+      input: payload.action,
+      action: payload.action,
+      data: payload.data,
+      playerId: this.playerId,
+    }).subscribe();
+    this.webSocket.emit('action', payload)
   }
 
   get PIXI() {
@@ -1335,8 +1594,76 @@ export class RpgClientEngine<T = any> {
     return this.sceneMap
   }
 
+  getObjectById(id: string) {
+    return this.sceneMap?.getObjectById(id);
+  }
+
   private getPhysicsTick(): number {
-    return this.sceneMap?.getTick?.() ?? 0;
+    return (this.sceneMap as any)?.getTick?.() ?? 0;
+  }
+
+  private getPhysicsTickDurationMs(): number {
+    const timeStep = (this.sceneMap as any)?.physic?.getWorld?.()?.getTimeStep?.();
+    return typeof timeStep === "number" && Number.isFinite(timeStep) && timeStep > 0
+      ? timeStep * 1000
+      : 1000 / 60;
+  }
+
+  private updateServerTickEstimate(serverTick: number | undefined, now = Date.now()): void {
+    if (typeof serverTick !== "number" || !Number.isFinite(serverTick)) {
+      return;
+    }
+    this.latestServerTick = serverTick;
+    this.latestServerTickAt = now;
+  }
+
+  private estimateServerTick(now = Date.now()): number | undefined {
+    if (typeof this.latestServerTick !== "number" || this.latestServerTickAt <= 0) {
+      return undefined;
+    }
+    const elapsedTicks = Math.max(0, (now - this.latestServerTickAt) / this.getPhysicsTickDurationMs());
+    return this.latestServerTick + elapsedTicks;
+  }
+
+  private predictProjectileImpact(projectile: ClientProjectileSpawn): ClientProjectileImpact | null {
+    if (projectile.predictImpact === false) {
+      return null;
+    }
+    const sceneMap = this.sceneMap as any;
+    if (!sceneMap?.physic || !Number.isFinite(projectile.range) || projectile.range <= 0) {
+      return null;
+    }
+    const origin = projectile.origin;
+    const direction = projectile.direction;
+    if (
+      !origin ||
+      !direction ||
+      !Number.isFinite(origin.x) ||
+      !Number.isFinite(origin.y) ||
+      !Number.isFinite(direction.x) ||
+      !Number.isFinite(direction.y) ||
+      (direction.x === 0 && direction.y === 0)
+    ) {
+      return null;
+    }
+
+    const hit = sceneMap.physic.raycast(
+      new Vector2(origin.x, origin.y),
+      new Vector2(direction.x, direction.y),
+      projectile.range,
+      projectile.collisionMask,
+      (entity) => projectile.ignoreOwner === false || !projectile.ownerId || entity.uuid !== projectile.ownerId,
+    );
+    if (!hit) {
+      return null;
+    }
+    return {
+      id: projectile.id,
+      targetId: hit.entity.uuid,
+      x: hit.point.x,
+      y: hit.point.y,
+      distance: hit.distance,
+    };
   }
 
   private ensureCurrentPlayerBody(): boolean {
@@ -1686,6 +2013,7 @@ export class RpgClientEngine<T = any> {
   }
 
   private applyServerAck(ack: { frame: number; serverTick?: number; x?: number; y?: number; direction?: Direction }) {
+    this.updateServerTickEstimate(ack.serverTick);
     if (this.predictionEnabled && this.prediction) {
       const result = this.prediction.applyServerAck({
         frame: ack.frame,
@@ -1847,6 +2175,13 @@ export class RpgClientEngine<T = any> {
         this.resizeHandler = undefined;
       }
 
+      if (this.pointerMoveHandler && this.pointerCanvas) {
+        this.pointerCanvas.removeEventListener('pointermove', this.pointerMoveHandler);
+        this.pointerCanvas.removeEventListener('pointerdown', this.pointerMoveHandler);
+        this.pointerMoveHandler = undefined;
+        this.pointerCanvas = undefined;
+      }
+
       // Destroy PIXI app and renderer if they exist
       // Destroy the app first, which will destroy the renderer
       // Store renderer reference before destroying app (since app.destroy() will destroy the renderer)
@@ -1920,6 +2255,7 @@ export class RpgClientEngine<T = any> {
       this.cameraFollowTargetId.set(null);
       this.spriteComponentsBehind.set([]);
       this.spriteComponentsInFront.set([]);
+      this.eventComponentResolvers.clear();
       
       // Clear maps and arrays
       this.spritesheets.clear();