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

package/dist/Game/Object.js.map

@@ -1 +1 @@
-{"version":3,"file":"Object.js","names":[],"sources":["../../src/Game/Object.ts"],"sourcesContent":["import { Hooks, ModulesToken, RpgCommonPlayer } from \"@rpgjs/common\";\nimport { trigger, signal, effect } from \"canvasengine\";\nimport { filter, from, map, Subscription, switchMap } from \"rxjs\";\nimport { inject } from \"../core/inject\";\nimport { RpgClientEngine } from \"../RpgClientEngine\";\nimport TextComponent from \"../components/dynamics/text.ce\";\n\nconst DYNAMIC_COMPONENTS = {\n  text: TextComponent,\n}\n\ntype Frame = { x: number; y: number; ts: number };\n\nexport abstract class RpgClientObject extends RpgCommonPlayer {\n  abstract _type: string;\n  emitParticleTrigger = trigger();\n  particleName = signal(\"\");\n  animationCurrentIndex = signal(0);\n  animationIsPlaying = signal(false);\n  _param = signal({});\n  frames: Frame[] = [];\n  graphicsSignals = signal<any[]>([]);\n  _component = {} // temporary component memory\n  flashTrigger = trigger();\n\n  constructor() {\n    super();\n    this.hooks.callHooks(\"client-sprite-onInit\", this).subscribe();\n\n    this._frames.observable.subscribe(({ items }) => {\n      if (!this.id) return;\n      //if (this.id == this.engine.playerIdSignal()!) return;\n      const nextFrames = items.flatMap((item): Frame[] =>\n        Array.isArray(item) ? item : [item]\n      );\n      this.frames = [...this.frames, ...nextFrames];\n    });\n\n    this.graphics.observable\n    .pipe(\n      map(({ items }) => items),\n      filter(graphics => graphics.length > 0),\n      switchMap(graphics => from(Promise.all(graphics.map(graphic => this.engine.getSpriteSheet(graphic)))))\n    )\n    .subscribe((sheets) => {  \n      this.graphicsSignals.set(sheets);\n    });\n\n    this.componentsTop.observable\n    .pipe(\n      filter(value => value !== null && value !== undefined),\n      map((value) => typeof value === 'string' ? JSON.parse(value) : value),\n    )\n    .subscribe(({components}) => {\n      for (const component of components) {\n        for (const [key, value] of Object.entries(component)) {\n          this._component = value as any; // temporary component memory\n          console.log(value)\n          const type = (value as any).type as keyof typeof DYNAMIC_COMPONENTS;\n          if (DYNAMIC_COMPONENTS[type]) {\n            this.engine.addSpriteComponentInFront(DYNAMIC_COMPONENTS[type]);\n          }\n        }\n      }\n    });\n\n    this.engine.tick\n      .pipe\n      //throttleTime(10)\n      ()\n      .subscribe(() => {\n        const frame = this.frames.shift();\n        if (frame) {\n          if (typeof frame.x !== \"number\" || typeof frame.y !== \"number\") return;\n          this.engine.scene.setBodyPosition(\n            this.id,\n            frame.x,\n            frame.y,\n            \"top-left\"\n          );\n        }\n      });\n  }\n\n  /**\n   * Access the shared client hook registry.\n   *\n   * @returns The hook service used to register and trigger client-side hooks.\n   */\n  get hooks() {\n    return inject<Hooks>(ModulesToken);\n  }\n\n  /**\n   * Access the current client engine instance.\n   *\n   * @returns The active {@link RpgClientEngine} instance.\n   */\n  get engine() {\n    return inject(RpgClientEngine);\n  }\n\n  private animationSubscription?: Subscription;\n\n  /**\n   * Trigger a flash animation on this sprite\n   * \n   * This method triggers a flash effect using CanvasEngine's flash directive.\n   * The flash can be configured with various options including type (alpha, tint, or both),\n   * duration, cycles, and color.\n   * \n   * ## Design\n   * \n   * The flash uses a trigger system that is connected to the flash directive in the\n   * character component. This allows for flexible configuration and can be triggered\n   * from both server events and client-side code.\n   * \n   * @param options - Flash configuration options\n   * @param options.type - Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both' (default: 'alpha')\n   * @param options.duration - Duration of the flash animation in milliseconds (default: 300)\n   * @param options.cycles - Number of flash cycles (flash on/off) (default: 1)\n   * @param options.alpha - Alpha value when flashing, from 0 to 1 (default: 0.3)\n   * @param options.tint - Tint color when flashing as hex value or color name (default: 0xffffff - white)\n   * \n   * @example\n   * ```ts\n   * // Simple flash with default settings (alpha flash)\n   * player.flash();\n   * \n   * // Flash with red tint\n   * player.flash({ type: 'tint', tint: 0xff0000 });\n   * \n   * // Flash with both alpha and tint\n   * player.flash({ \n   *   type: 'both', \n   *   alpha: 0.5, \n   *   tint: 0xff0000,\n   *   duration: 200,\n   *   cycles: 2\n   * });\n   * \n   * // Quick damage flash\n   * player.flash({ \n   *   type: 'tint', \n   *   tint: 0xff0000, \n   *   duration: 150,\n   *   cycles: 1\n   * });\n   * ```\n   */\n  flash(options?: {\n    type?: 'alpha' | 'tint' | 'both';\n    duration?: number;\n    cycles?: number;\n    alpha?: number;\n    tint?: number | string;\n  }): void {\n    const flashOptions = {\n      type: options?.type || 'alpha',\n      duration: options?.duration ?? 300,\n      cycles: options?.cycles ?? 1,\n      alpha: options?.alpha ?? 0.3,\n      tint: options?.tint ?? 0xffffff,\n    };\n    \n    // Convert color name to hex if needed\n    let tintValue = flashOptions.tint;\n    if (typeof tintValue === 'string') {\n      // Common color name to hex mapping\n      const colorMap: Record<string, number> = {\n        'white': 0xffffff,\n        'red': 0xff0000,\n        'green': 0x00ff00,\n        'blue': 0x0000ff,\n        'yellow': 0xffff00,\n        'cyan': 0x00ffff,\n        'magenta': 0xff00ff,\n        'black': 0x000000,\n      };\n      tintValue = colorMap[tintValue.toLowerCase()] ?? 0xffffff;\n    }\n    \n    this.flashTrigger.start({\n      ...flashOptions,\n      tint: tintValue,\n    });\n  }\n\n  /**\n   * Reset animation state when animation changes externally\n   *\n   * This method should be called when the animation changes due to movement\n   * or other external factors to ensure the animation system doesn't get stuck\n   *\n   * @example\n   * ```ts\n   * // Reset when player starts moving\n   * player.resetAnimationState();\n   * ```\n   */\n  resetAnimationState() {\n    this.animationIsPlaying.set(false);\n    this.animationCurrentIndex.set(0);\n    if (this.animationSubscription) {\n      this.animationSubscription.unsubscribe();\n      this.animationSubscription = undefined;\n    }\n  }\n\n  /**\n   * Set a custom animation for a specific number of times\n   *\n   * Plays a custom animation for the specified number of repetitions.\n   * The animation system prevents overlapping animations and automatically\n   * returns to the previous animation when complete.\n   *\n   * @param animationName - Name of the animation to play\n   * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)\n   *\n   * @example\n   * ```ts\n   * // Play attack animation 3 times\n   * player.setAnimation('attack', 3);\n   *\n   * // Play continuous spell animation\n   * player.setAnimation('spell');\n   * ```\n   */\n  setAnimation(animationName: string, nbTimes?: number): void;\n  /**\n   * Set a custom animation with temporary graphic change\n   *\n   * Plays a custom animation for the specified number of repetitions and temporarily\n   * changes the player's graphic (sprite sheet) during the animation. The graphic\n   * is automatically reset when the animation finishes.\n   *\n   * @param animationName - Name of the animation to play\n   * @param graphic - The graphic(s) to temporarily use during the animation\n   * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)\n   *\n   * @example\n   * ```ts\n   * // Play attack animation with temporary graphic change\n   * player.setAnimation('attack', 'hero_attack', 3);\n   * ```\n   */\n  setAnimation(animationName: string, graphic?: string | string[], nbTimes?: number): void;\n  setAnimation(animationName: string, graphicOrNbTimes?: string | string[] | number, nbTimes?: number): void {\n    if (this.animationIsPlaying()) return;\n    this.animationIsPlaying.set(true);\n    const previousAnimationName = this.animationName();\n    const previousGraphics = this.graphics();\n    this.animationCurrentIndex.set(0);\n\n    let graphic: string | string[] | undefined;\n    let finalNbTimes: number = Infinity;\n\n    // Handle overloads\n    if (typeof graphicOrNbTimes === 'number') {\n      // setAnimation(animationName, nbTimes)\n      finalNbTimes = graphicOrNbTimes;\n    } else if (graphicOrNbTimes !== undefined) {\n      // setAnimation(animationName, graphic, nbTimes)\n      graphic = graphicOrNbTimes;\n      finalNbTimes = nbTimes ?? Infinity;\n    } else {\n      // setAnimation(animationName) - nbTimes remains Infinity\n      finalNbTimes = Infinity;\n    }\n\n    // Temporarily change graphic if provided\n    if (graphic !== undefined) {\n      if (Array.isArray(graphic)) {\n        this.graphics.set(graphic);\n      } else {\n        this.graphics.set([graphic]);\n      }\n    }\n\n    // Clean up any existing subscription\n    if (this.animationSubscription) {\n      this.animationSubscription.unsubscribe();\n    }\n\n    this.animationSubscription =\n      this.animationCurrentIndex.observable.subscribe((index) => {\n        if (index >= finalNbTimes) {\n          this.animationCurrentIndex.set(0);\n          this.animationName.set(previousAnimationName);\n          // Reset graphic to previous value if it was changed\n          if (graphic !== undefined) {\n            this.graphics.set(previousGraphics);\n          }\n          this.animationIsPlaying.set(false);\n          if (this.animationSubscription) {\n            this.animationSubscription.unsubscribe();\n            this.animationSubscription = undefined;\n          }\n        }\n      });\n    this.animationName.set(animationName);\n  }\n\n  /**\n   * Display a registered component animation effect on this object.\n   *\n   * @param id - Identifier of the component animation to play.\n   * @param params - Parameters forwarded to the animation effect.\n   */\n  showComponentAnimation(id: string, params: any) {\n    const engine = inject(RpgClientEngine);\n    engine.getComponentAnimation(id).displayEffect(params, this);\n  }\n  \n  /**\n   * Check whether this client object represents an event.\n   *\n   * @returns `true` if the object type is `event`, otherwise `false`.\n   */\n  isEvent(): boolean {\n    return this._type === 'event';\n  }\n\n  /**\n   * Check whether this client object represents a player.\n   *\n   * @returns `true` if the object type is `player`, otherwise `false`.\n   */\n  isPlayer(): boolean {\n    return this._type === 'player';\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"Object.js","names":[],"sources":["../../src/Game/Object.ts"],"sourcesContent":["import { Hooks, ModulesToken, RpgCommonPlayer } from \"@rpgjs/common\";\nimport { trigger, signal, type Trigger } from \"canvasengine\";\nimport { from, map, of, Subscription, switchMap } from \"rxjs\";\nimport { inject } from \"../core/inject\";\nimport { RpgClientEngine } from \"../RpgClientEngine\";\ntype Frame = { x: number; y: number; ts: number };\n\ntype AnimationRestoreOptions = {\n  restoreAnimationName?: string;\n  restoreGraphics?: any[];\n  timeoutMs?: number;\n};\n\ntype FlashType = 'alpha' | 'tint' | 'both';\n\ntype FlashOptions = {\n  type?: FlashType;\n  duration?: number;\n  cycles?: number;\n  alpha?: number;\n  tint?: number | string;\n};\n\ntype FlashTriggerOptions = Omit<FlashOptions, \"tint\"> & {\n  tint: number;\n};\n\ntype ConfigurableTrigger<T> = Omit<Trigger<T>, \"start\"> & {\n  start(config?: T): Promise<void>;\n};\n\nexport abstract class RpgClientObject extends RpgCommonPlayer {\n  abstract _type: string;\n  emitParticleTrigger = trigger();\n  particleName = signal(\"\");\n  animationCurrentIndex = signal(0);\n  animationIsPlaying = signal(false);\n  _param = signal({});\n  frames: Frame[] = [];\n  graphicsSignals = signal<any[]>([]);\n  flashTrigger: ConfigurableTrigger<FlashTriggerOptions> = trigger<FlashTriggerOptions>();\n  private animationRestoreState?: {\n    animationName: string;\n    graphics: any[];\n  };\n\n  constructor() {\n    super();\n    this.hooks.callHooks(\"client-sprite-onInit\", this).subscribe();\n\n    this._frames.observable.subscribe(({ items }) => {\n      if (!this.id) return;\n      //if (this.id == this.engine.playerIdSignal()!) return;\n      const nextFrames = items.flatMap((item): Frame[] =>\n        Array.isArray(item) ? item : [item]\n      );\n      this.frames = [...this.frames, ...nextFrames];\n    });\n\n    this.graphics.observable\n    .pipe(\n      map(({ items }) => items),\n      switchMap(graphics => {\n        if (graphics.length === 0) return of([]);\n        return from(Promise.all(graphics.map(graphic => this.engine.getSpriteSheet(graphic))));\n      })\n    )\n    .subscribe((sheets) => {  \n      this.graphicsSignals.set(sheets);\n    });\n\n    this.engine.tick\n      .pipe\n      //throttleTime(10)\n      ()\n      .subscribe(() => {\n        const frame = this.frames.shift();\n        if (frame) {\n          if (typeof frame.x !== \"number\" || typeof frame.y !== \"number\") return;\n          this.engine.scene.setBodyPosition(\n            this.id,\n            frame.x,\n            frame.y,\n            \"top-left\"\n          );\n        }\n      });\n  }\n\n  /**\n   * Access the shared client hook registry.\n   *\n   * @returns The hook service used to register and trigger client-side hooks.\n   */\n  get hooks() {\n    return inject<Hooks>(ModulesToken);\n  }\n\n  /**\n   * Access the current client engine instance.\n   *\n   * @returns The active {@link RpgClientEngine} instance.\n   */\n  get engine() {\n    return inject(RpgClientEngine);\n  }\n\n  private animationSubscription?: Subscription;\n  private animationResetTimeout?: ReturnType<typeof setTimeout>;\n  private animationWaitResolve?: () => void;\n\n  private clearAnimationControls() {\n    if (this.animationSubscription) {\n      this.animationSubscription.unsubscribe();\n      this.animationSubscription = undefined;\n    }\n    if (this.animationResetTimeout) {\n      clearTimeout(this.animationResetTimeout);\n      this.animationResetTimeout = undefined;\n    }\n  }\n\n  private resolveAnimationWait() {\n    const resolve = this.animationWaitResolve;\n    this.animationWaitResolve = undefined;\n    resolve?.();\n  }\n\n  private finishTemporaryAnimation() {\n    const restoreState = this.animationRestoreState;\n    this.clearAnimationControls();\n    this.animationCurrentIndex.set(0);\n    if (restoreState) {\n      this.animationName.set(restoreState.animationName);\n      this.graphics.set([...restoreState.graphics]);\n    }\n    this.animationRestoreState = undefined;\n    this.animationIsPlaying.set(false);\n    this.resolveAnimationWait();\n  }\n\n  /**\n   * Trigger a flash animation on this sprite\n   * \n   * This method triggers a flash effect using CanvasEngine's flash directive.\n   * The flash can be configured with various options including type (alpha, tint, or both),\n   * duration, cycles, and color.\n   * \n   * ## Design\n   * \n   * The flash uses a trigger system that is connected to the flash directive in the\n   * character component. This allows for flexible configuration and can be triggered\n   * from both server events and client-side code.\n   * \n   * @param options - Flash configuration options\n   * @param options.type - Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both' (default: 'alpha')\n   * @param options.duration - Duration of the flash animation in milliseconds (default: 300)\n   * @param options.cycles - Number of flash cycles (flash on/off) (default: 1)\n   * @param options.alpha - Alpha value when flashing, from 0 to 1 (default: 0.3)\n   * @param options.tint - Tint color when flashing as hex value or color name (default: 0xffffff - white)\n   * \n   * @example\n   * ```ts\n   * // Simple flash with default settings (alpha flash)\n   * player.flash();\n   * \n   * // Flash with red tint\n   * player.flash({ type: 'tint', tint: 0xff0000 });\n   * \n   * // Flash with both alpha and tint\n   * player.flash({ \n   *   type: 'both', \n   *   alpha: 0.5, \n   *   tint: 0xff0000,\n   *   duration: 200,\n   *   cycles: 2\n   * });\n   * \n   * // Quick damage flash\n   * player.flash({ \n   *   type: 'tint', \n   *   tint: 0xff0000, \n   *   duration: 150,\n   *   cycles: 1\n   * });\n   * ```\n   */\n  flash(options?: FlashOptions): void {\n    const flashOptions = {\n      type: options?.type || 'alpha',\n      duration: options?.duration ?? 300,\n      cycles: options?.cycles ?? 1,\n      alpha: options?.alpha ?? 0.3,\n      tint: options?.tint ?? 0xffffff,\n    };\n    \n    // Convert color name to hex if needed\n    let tintValue = flashOptions.tint;\n    if (typeof tintValue === 'string') {\n      // Common color name to hex mapping\n      const colorMap: Record<string, number> = {\n        'white': 0xffffff,\n        'red': 0xff0000,\n        'green': 0x00ff00,\n        'blue': 0x0000ff,\n        'yellow': 0xffff00,\n        'cyan': 0x00ffff,\n        'magenta': 0xff00ff,\n        'black': 0x000000,\n      };\n      tintValue = colorMap[tintValue.toLowerCase()] ?? 0xffffff;\n    }\n    \n    this.flashTrigger.start({\n      ...flashOptions,\n      tint: tintValue,\n    });\n  }\n\n  /**\n   * Reset animation state when animation changes externally\n   *\n   * This method should be called when the animation changes due to movement\n   * or other external factors to ensure the animation system doesn't get stuck\n   *\n   * @example\n   * ```ts\n   * // Reset when player starts moving\n   * player.resetAnimationState();\n   * ```\n   */\n  resetAnimationState() {\n    if (this.animationRestoreState) {\n      this.finishTemporaryAnimation();\n      return;\n    }\n    this.animationIsPlaying.set(false);\n    this.animationCurrentIndex.set(0);\n    this.clearAnimationControls();\n    this.resolveAnimationWait();\n  }\n\n  /**\n   * Set a custom animation for a specific number of times\n   *\n   * Plays a custom animation for the specified number of repetitions.\n   * The animation system prevents overlapping animations and automatically\n   * returns to the previous animation when complete.\n   *\n   * @param animationName - Name of the animation to play\n   * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)\n   * @param options - Restore and timeout options\n   * @returns A promise resolved when a finite animation finishes, is interrupted, or times out\n   *\n   * @example\n   * ```ts\n   * // Play attack animation 3 times\n   * await player.setAnimation('attack', 3);\n   *\n   * // Play continuous spell animation\n   * player.setAnimation('spell');\n   * ```\n   */\n  setAnimation(animationName: string, nbTimes?: number, options?: AnimationRestoreOptions): Promise<void>;\n  /**\n   * Set a custom animation with temporary graphic change\n   *\n   * Plays a custom animation for the specified number of repetitions and temporarily\n   * changes the player's graphic (sprite sheet) during the animation. The graphic\n   * is automatically reset when the animation finishes.\n   *\n   * @param animationName - Name of the animation to play\n   * @param graphic - The graphic(s) to temporarily use during the animation\n   * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)\n   * @param options - Restore and timeout options\n   * @returns A promise resolved when a finite animation finishes, is interrupted, or times out\n   *\n   * @example\n   * ```ts\n   * // Play attack animation with temporary graphic change\n   * await player.setAnimation('attack', 'hero_attack', 3);\n   * ```\n   */\n  setAnimation(animationName: string, graphic?: string | string[], nbTimes?: number, options?: AnimationRestoreOptions): Promise<void>;\n  setAnimation(\n    animationName: string,\n    graphicOrNbTimes?: string | string[] | number,\n    nbTimesOrOptions?: number | AnimationRestoreOptions,\n    options?: AnimationRestoreOptions\n  ): Promise<void> {\n    let graphic: string | string[] | undefined;\n    let finalNbTimes: number = Infinity;\n    let restoreOptions: AnimationRestoreOptions | undefined = options;\n\n    // Handle overloads\n    if (typeof graphicOrNbTimes === 'number') {\n      // setAnimation(animationName, nbTimes)\n      finalNbTimes = graphicOrNbTimes;\n      restoreOptions = typeof nbTimesOrOptions === 'object' ? nbTimesOrOptions : options;\n    } else if (graphicOrNbTimes !== undefined) {\n      // setAnimation(animationName, graphic, nbTimes)\n      graphic = graphicOrNbTimes;\n      if (typeof nbTimesOrOptions === 'number') {\n        finalNbTimes = nbTimesOrOptions;\n      } else {\n        finalNbTimes = Infinity;\n        restoreOptions = nbTimesOrOptions ?? options;\n      }\n    } else {\n      // setAnimation(animationName) - nbTimes remains Infinity\n      finalNbTimes = Infinity;\n    }\n\n    if (this.animationIsPlaying()) {\n      this.finishTemporaryAnimation();\n    }\n\n    const waitPromise =\n      finalNbTimes === Infinity\n        ? Promise.resolve()\n        : new Promise<void>((resolve) => {\n            this.animationWaitResolve = resolve;\n          });\n\n    this.animationIsPlaying.set(true);\n    const previousAnimationName =\n      restoreOptions?.restoreAnimationName ?? this.animationName();\n    const previousGraphics = restoreOptions?.restoreGraphics\n      ? [...restoreOptions.restoreGraphics]\n      : [...this.graphics()];\n    this.animationRestoreState = {\n      animationName: previousAnimationName,\n      graphics: previousGraphics,\n    };\n    this.animationCurrentIndex.set(0);\n\n    // Temporarily change graphic if provided\n    if (graphic !== undefined) {\n      if (Array.isArray(graphic)) {\n        this.graphics.set(graphic);\n      } else {\n        this.graphics.set([graphic]);\n      }\n    }\n\n    this.clearAnimationControls();\n\n    this.animationSubscription =\n      this.animationCurrentIndex.observable.subscribe((index) => {\n        if (index >= finalNbTimes) {\n          this.finishTemporaryAnimation();\n        }\n      });\n\n    if (finalNbTimes !== Infinity) {\n      this.animationResetTimeout = setTimeout(() => {\n        if (this.animationIsPlaying()) {\n          this.finishTemporaryAnimation();\n        }\n      }, restoreOptions?.timeoutMs ?? Math.max(1000, finalNbTimes * 1000));\n    }\n\n    this.animationName.set(animationName);\n\n    return waitPromise;\n  }\n\n  /**\n   * Display a registered component animation effect on this object.\n   *\n   * @param id - Identifier of the component animation to play.\n   * @param params - Parameters forwarded to the animation effect.\n   * @returns A promise resolved when the animation component calls `onFinish`.\n   */\n  showComponentAnimation(id: string, params: any): Promise<void> {\n    const engine = inject(RpgClientEngine);\n    return engine.getComponentAnimation(id).displayEffect(params, this);\n  }\n\n  /**\n   * Display a registered spritesheet animation effect on this object.\n   *\n   * @param graphic - Identifier of the spritesheet to use.\n   * @param animationName - Name of the animation inside the spritesheet.\n   * @returns A promise resolved when the animation component calls `onFinish`.\n   */\n  showAnimation(graphic: string, animationName: string = 'default'): Promise<void> {\n    return this.showComponentAnimation('animation', {\n      graphic,\n      animationName,\n    });\n  }\n  \n  /**\n   * Check whether this client object represents an event.\n   *\n   * @returns `true` if the object type is `event`, otherwise `false`.\n   */\n  isEvent(): boolean {\n    return this._type === 'event';\n  }\n\n  /**\n   * Check whether this client object represents a player.\n   *\n   * @returns `true` if the object type is `player`, otherwise `false`.\n   */\n  isPlayer(): boolean {\n    return this._type === 'player';\n  }\n}\n"],"mappings":"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"}

package/dist/Game/Player.js.map

@@ -1 +1 @@
-{"version":3,"file":"Player.js","names":[],"sources":["../../src/Game/Player.ts"],"sourcesContent":["import { RpgClientObject } from \"./Object\";\n\nexport class RpgClientPlayer extends RpgClientObject {\n    _type = 'player'\n}   "],"mappings":";;AAEA,IAAa,kBAAb,cAAqC,gBAAgB;;;eACzC"}
+{"version":3,"file":"Player.js","names":[],"sources":["../../src/Game/Player.ts"],"sourcesContent":["import { RpgClientObject } from \"./Object\";\n\nexport class RpgClientPlayer extends RpgClientObject {\n    _type = 'player'\n}   "],"mappings":";;AAEA,IAAa,kBAAb,cAAqC,gBAAgB;;;eACzC;;AACZ"}

package/dist/Game/ProjectileManager.d.ts

@@ -0,0 +1,89 @@
+import { Hooks } from '@rpgjs/common';
+export interface ClientProjectileSpawn {
+    id: string;
+    type: string;
+    ownerId?: string;
+    origin: {
+        x: number;
+        y: number;
+    };
+    direction: {
+        x: number;
+        y: number;
+    };
+    speed: number;
+    range: number;
+    ttl: number;
+    spawnTick: number;
+    delay?: number;
+    index?: number;
+    count?: number;
+    params?: Record<string, unknown>;
+    collisionMask?: number;
+    ignoreOwner?: boolean;
+    predictImpact?: boolean;
+}
+export interface ClientProjectileImpact {
+    id: string;
+    targetId?: string;
+    x: number;
+    y: number;
+    distance?: number;
+}
+export interface ClientProjectileDestroy {
+    id: string;
+    reason?: string;
+    targetId?: string;
+    x?: number;
+    y?: number;
+    distance?: number;
+}
+export interface RenderedProjectileProps extends ClientProjectileSpawn {
+    x: number;
+    y: number;
+    angle: number;
+    distance: number;
+    elapsed: number;
+    progress: number;
+    impact?: ClientProjectileImpact;
+    impactElapsed?: number;
+    impactProgress?: number;
+    destroyed?: boolean;
+}
+export interface RenderedProjectile {
+    id: string;
+    type: string;
+    component: any;
+    props: RenderedProjectileProps;
+}
+export type ProjectilePredictionResolver = (projectile: ClientProjectileSpawn) => ClientProjectileImpact | null | undefined;
+export interface ProjectileSpawnClock {
+    now?: number;
+    currentServerTick?: number;
+    tickDurationMs?: number;
+}
+export declare class ProjectileManager {
+    private readonly hooks;
+    private readonly predictionResolver?;
+    private readonly components;
+    private readonly projectiles;
+    private readonly version;
+    private readonly impactDurationMs;
+    constructor(hooks: Hooks, predictionResolver?: ProjectilePredictionResolver | undefined);
+    current: import('canvasengine').ComputedSignal<RenderedProjectile[]>;
+    register(type: string, component: any): any;
+    get(type: string): any;
+    spawnBatch(projectiles: ClientProjectileSpawn[], clock?: ProjectileSpawnClock): void;
+    impactBatch(impacts: ClientProjectileImpact[]): void;
+    destroyBatch(projectiles: ClientProjectileDestroy[]): void;
+    clear(): void;
+    step(): void;
+    private toProps;
+    private isWaitingForDelay;
+    private setPredictedImpact;
+    private getActivePredictedImpact;
+    private setImpact;
+    private resolveVisualImpact;
+    private isSameTarget;
+    private touch;
+}

package/dist/Game/ProjectileManager.js

@@ -0,0 +1,179 @@
+import { computed, signal } from "canvasengine";
+//#region src/Game/ProjectileManager.ts
+var ProjectileManager = class {
+	constructor(hooks, predictionResolver) {
+		this.hooks = hooks;
+		this.predictionResolver = predictionResolver;
+		this.components = /* @__PURE__ */ new Map();
+		this.projectiles = /* @__PURE__ */ new Map();
+		this.version = signal(0);
+		this.impactDurationMs = 350;
+		this.current = computed(() => {
+			this.version();
+			const now = Date.now();
+			const rendered = [];
+			for (const projectile of this.projectiles.values()) {
+				const props = this.toProps(projectile, now);
+				if (!props) continue;
+				rendered.push({
+					id: projectile.spawn.id,
+					type: projectile.spawn.type,
+					component: projectile.component,
+					props
+				});
+			}
+			return rendered;
+		});
+	}
+	register(type, component) {
+		this.components.set(type, component);
+		return component;
+	}
+	get(type) {
+		return this.components.get(type);
+	}
+	spawnBatch(projectiles, clock = {}) {
+		const now = clock.now ?? Date.now();
+		for (const projectile of projectiles) {
+			const component = this.components.get(projectile.type);
+			if (!component) continue;
+			const runtime = {
+				spawn: {
+					...projectile,
+					delay: projectile.delay ?? 0,
+					index: projectile.index ?? 0,
+					count: projectile.count ?? 1
+				},
+				component,
+				createdAt: now
+			};
+			this.setPredictedImpact(runtime);
+			this.projectiles.set(projectile.id, runtime);
+			this.hooks.callHooks("client-projectiles-onSpawn", runtime.spawn).subscribe();
+		}
+		this.touch();
+	}
+	impactBatch(impacts) {
+		const now = Date.now();
+		for (const impact of impacts) {
+			const projectile = this.projectiles.get(impact.id);
+			if (!projectile) continue;
+			this.setImpact(projectile, impact, now);
+			this.hooks.callHooks("client-projectiles-onImpact", this.toProps(projectile, now)).subscribe();
+		}
+		this.touch();
+	}
+	destroyBatch(projectiles) {
+		const now = Date.now();
+		for (const destroyed of projectiles) {
+			const projectile = this.projectiles.get(destroyed.id);
+			if (!projectile) continue;
+			if (destroyed.reason === "hit") {
+				const current = this.toProps(projectile, now);
+				this.setImpact(projectile, {
+					id: destroyed.id,
+					targetId: destroyed.targetId ?? projectile.impact?.targetId,
+					x: destroyed.x ?? projectile.impact?.x ?? current?.x ?? projectile.spawn.origin.x,
+					y: destroyed.y ?? projectile.impact?.y ?? current?.y ?? projectile.spawn.origin.y,
+					distance: destroyed.distance ?? projectile.impact?.distance ?? current?.distance
+				}, now);
+			}
+			projectile.destroyReason = destroyed.reason;
+			projectile.destroyAt = projectile.destroyAt ?? (projectile.impact && projectile.impactStartedAt !== void 0 ? projectile.impactStartedAt + this.impactDurationMs : now);
+			this.hooks.callHooks("client-projectiles-onDestroy", this.toProps(projectile, now)).subscribe();
+		}
+		this.touch();
+	}
+	clear() {
+		this.projectiles.clear();
+		this.touch();
+	}
+	step() {
+		const now = Date.now();
+		let changed = false;
+		for (const [id, projectile] of this.projectiles) if (!this.toProps(projectile, now) && !this.isWaitingForDelay(projectile, now) || projectile.destroyAt !== void 0 && now >= projectile.destroyAt) {
+			this.projectiles.delete(id);
+			changed = true;
+		}
+		this.touch(changed || this.projectiles.size > 0);
+	}
+	toProps(projectile, now) {
+		const spawn = projectile.spawn;
+		const delayMs = (spawn.delay ?? 0) * 1e3;
+		const elapsedMs = now - projectile.createdAt - delayMs;
+		if (elapsedMs < 0) return null;
+		const elapsed = elapsedMs / 1e3;
+		const ttl = Math.max(.001, spawn.ttl);
+		const rawDistance = Math.min(spawn.speed * elapsed, spawn.range);
+		const predictedImpact = this.getActivePredictedImpact(projectile, now, rawDistance);
+		const visualImpact = projectile.visualImpact ?? projectile.impact;
+		const distance = visualImpact?.distance ?? predictedImpact?.distance ?? rawDistance;
+		const progress = Math.min(1, distance / spawn.range);
+		const x = visualImpact?.x ?? predictedImpact?.x ?? spawn.origin.x + spawn.direction.x * distance;
+		const y = visualImpact?.y ?? predictedImpact?.y ?? spawn.origin.y + spawn.direction.y * distance;
+		const impactElapsedMs = projectile.impactStartedAt !== void 0 ? Math.max(0, now - projectile.impactStartedAt) : void 0;
+		return {
+			...spawn,
+			x,
+			y,
+			angle: Math.atan2(spawn.direction.y, spawn.direction.x),
+			distance,
+			elapsed,
+			progress,
+			impact: projectile.impact,
+			impactElapsed: impactElapsedMs === void 0 ? void 0 : impactElapsedMs / 1e3,
+			impactProgress: impactElapsedMs === void 0 ? void 0 : Math.min(1, impactElapsedMs / this.impactDurationMs),
+			destroyed: projectile.destroyAt !== void 0,
+			ttl
+		};
+	}
+	isWaitingForDelay(projectile, now) {
+		const delayMs = (projectile.spawn.delay ?? 0) * 1e3;
+		return now - projectile.createdAt - delayMs < 0;
+	}
+	setPredictedImpact(projectile) {
+		if (projectile.spawn.predictImpact === false) return;
+		const impact = this.predictionResolver?.(projectile.spawn);
+		if (!impact || !Number.isFinite(impact.x) || !Number.isFinite(impact.y)) return;
+		const distance = typeof impact.distance === "number" && Number.isFinite(impact.distance) ? impact.distance : Math.hypot(impact.x - projectile.spawn.origin.x, impact.y - projectile.spawn.origin.y);
+		if (!Number.isFinite(distance) || distance < 0 || distance > projectile.spawn.range) return;
+		projectile.predictedImpact = {
+			...impact,
+			distance
+		};
+	}
+	getActivePredictedImpact(projectile, now, rawDistance) {
+		if (!projectile.predictedImpact || projectile.impact) return;
+		const distance = projectile.predictedImpact.distance;
+		if (distance === void 0 || rawDistance < distance) return;
+		return projectile.predictedImpact;
+	}
+	setImpact(projectile, impact, now) {
+		projectile.visualImpact = this.resolveVisualImpact(projectile, impact, now);
+		projectile.impact = impact;
+		projectile.predictedImpact = void 0;
+		projectile.impactStartedAt = projectile.impactStartedAt ?? now;
+		const impactDestroyAt = projectile.impactStartedAt + this.impactDurationMs;
+		projectile.destroyAt = Math.max(projectile.destroyAt ?? 0, impactDestroyAt);
+	}
+	resolveVisualImpact(projectile, impact, now) {
+		const predicted = projectile.predictedImpact;
+		if (!predicted || !this.isSameTarget(predicted, impact)) return impact;
+		const distance = predicted.distance;
+		if (distance === void 0) return impact;
+		const delayMs = (projectile.spawn.delay ?? 0) * 1e3;
+		const elapsedMs = now - projectile.createdAt - delayMs;
+		if (elapsedMs < 0) return impact;
+		return Math.min(projectile.spawn.speed * (elapsedMs / 1e3), projectile.spawn.range) >= distance ? predicted : impact;
+	}
+	isSameTarget(a, b) {
+		return a.targetId !== void 0 && a.targetId === b.targetId;
+	}
+	touch(force = true) {
+		if (force) this.version.update((value) => value + 1);
+	}
+};
+//#endregion
+export { ProjectileManager };
+
+//# sourceMappingURL=ProjectileManager.js.map

package/dist/Game/ProjectileManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectileManager.js","names":[],"sources":["../../src/Game/ProjectileManager.ts"],"sourcesContent":["import { computed, signal } from \"canvasengine\";\nimport { Hooks } from \"@rpgjs/common\";\n\nexport interface ClientProjectileSpawn {\n  id: string;\n  type: string;\n  ownerId?: string;\n  origin: { x: number; y: number };\n  direction: { x: number; y: number };\n  speed: number;\n  range: number;\n  ttl: number;\n  spawnTick: number;\n  delay?: number;\n  index?: number;\n  count?: number;\n  params?: Record<string, unknown>;\n  collisionMask?: number;\n  ignoreOwner?: boolean;\n  predictImpact?: boolean;\n}\n\nexport interface ClientProjectileImpact {\n  id: string;\n  targetId?: string;\n  x: number;\n  y: number;\n  distance?: number;\n}\n\nexport interface ClientProjectileDestroy {\n  id: string;\n  reason?: string;\n  targetId?: string;\n  x?: number;\n  y?: number;\n  distance?: number;\n}\n\nexport interface RenderedProjectileProps extends ClientProjectileSpawn {\n  x: number;\n  y: number;\n  angle: number;\n  distance: number;\n  elapsed: number;\n  progress: number;\n  impact?: ClientProjectileImpact;\n  impactElapsed?: number;\n  impactProgress?: number;\n  destroyed?: boolean;\n}\n\nexport interface RenderedProjectile {\n  id: string;\n  type: string;\n  component: any;\n  props: RenderedProjectileProps;\n}\n\nexport type ProjectilePredictionResolver = (\n  projectile: ClientProjectileSpawn,\n) => ClientProjectileImpact | null | undefined;\n\nexport interface ProjectileSpawnClock {\n  now?: number;\n  currentServerTick?: number;\n  tickDurationMs?: number;\n}\n\ninterface RuntimeProjectile {\n  spawn: ClientProjectileSpawn;\n  component: any;\n  createdAt: number;\n  impact?: ClientProjectileImpact;\n  visualImpact?: ClientProjectileImpact;\n  predictedImpact?: ClientProjectileImpact;\n  impactStartedAt?: number;\n  destroyAt?: number;\n  destroyReason?: string;\n}\n\nexport class ProjectileManager {\n  private readonly components = new Map<string, any>();\n  private readonly projectiles = new Map<string, RuntimeProjectile>();\n  private readonly version = signal(0);\n  private readonly impactDurationMs = 350;\n\n  constructor(\n    private readonly hooks: Hooks,\n    private readonly predictionResolver?: ProjectilePredictionResolver,\n  ) {}\n\n  current = computed<RenderedProjectile[]>(() => {\n    this.version();\n    const now = Date.now();\n    const rendered: RenderedProjectile[] = [];\n    for (const projectile of this.projectiles.values()) {\n      const props = this.toProps(projectile, now);\n      if (!props) {\n        continue;\n      }\n      rendered.push({\n        id: projectile.spawn.id,\n        type: projectile.spawn.type,\n        component: projectile.component,\n        props,\n      });\n    }\n    return rendered;\n  });\n\n  register(type: string, component: any): any {\n    this.components.set(type, component);\n    return component;\n  }\n\n  get(type: string): any {\n    return this.components.get(type);\n  }\n\n  spawnBatch(projectiles: ClientProjectileSpawn[], clock: ProjectileSpawnClock = {}): void {\n    const now = clock.now ?? Date.now();\n    for (const projectile of projectiles) {\n      const component = this.components.get(projectile.type);\n      if (!component) {\n        continue;\n      }\n      const runtime: RuntimeProjectile = {\n        spawn: {\n          ...projectile,\n          delay: projectile.delay ?? 0,\n          index: projectile.index ?? 0,\n          count: projectile.count ?? 1,\n        },\n        component,\n        createdAt: now,\n      };\n      this.setPredictedImpact(runtime);\n      this.projectiles.set(projectile.id, runtime);\n      this.hooks.callHooks(\"client-projectiles-onSpawn\", runtime.spawn).subscribe();\n    }\n    this.touch();\n  }\n\n  impactBatch(impacts: ClientProjectileImpact[]): void {\n    const now = Date.now();\n    for (const impact of impacts) {\n      const projectile = this.projectiles.get(impact.id);\n      if (!projectile) {\n        continue;\n      }\n      this.setImpact(projectile, impact, now);\n      this.hooks.callHooks(\"client-projectiles-onImpact\", this.toProps(projectile, now)).subscribe();\n    }\n    this.touch();\n  }\n\n  destroyBatch(projectiles: ClientProjectileDestroy[]): void {\n    const now = Date.now();\n    for (const destroyed of projectiles) {\n      const projectile = this.projectiles.get(destroyed.id);\n      if (!projectile) {\n        continue;\n      }\n      if (destroyed.reason === \"hit\") {\n        const current = this.toProps(projectile, now);\n        this.setImpact(projectile, {\n          id: destroyed.id,\n          targetId: destroyed.targetId ?? projectile.impact?.targetId,\n          x: destroyed.x ?? projectile.impact?.x ?? current?.x ?? projectile.spawn.origin.x,\n          y: destroyed.y ?? projectile.impact?.y ?? current?.y ?? projectile.spawn.origin.y,\n          distance: destroyed.distance ?? projectile.impact?.distance ?? current?.distance,\n        }, now);\n      }\n      projectile.destroyReason = destroyed.reason;\n      projectile.destroyAt = projectile.destroyAt ?? (\n        projectile.impact && projectile.impactStartedAt !== undefined\n          ? projectile.impactStartedAt + this.impactDurationMs\n          : now\n      );\n      this.hooks.callHooks(\"client-projectiles-onDestroy\", this.toProps(projectile, now)).subscribe();\n    }\n    this.touch();\n  }\n\n  clear(): void {\n    this.projectiles.clear();\n    this.touch();\n  }\n\n  step(): void {\n    const now = Date.now();\n    let changed = false;\n    for (const [id, projectile] of this.projectiles) {\n      const props = this.toProps(projectile, now);\n      if (\n        (!props && !this.isWaitingForDelay(projectile, now)) ||\n        (projectile.destroyAt !== undefined && now >= projectile.destroyAt)\n      ) {\n        this.projectiles.delete(id);\n        changed = true;\n      }\n    }\n    this.touch(changed || this.projectiles.size > 0);\n  }\n\n  private toProps(projectile: RuntimeProjectile, now: number): RenderedProjectileProps | null {\n    const spawn = projectile.spawn;\n    const delayMs = (spawn.delay ?? 0) * 1000;\n    const elapsedMs = now - projectile.createdAt - delayMs;\n    if (elapsedMs < 0) {\n      return null;\n    }\n    const elapsed = elapsedMs / 1000;\n    const ttl = Math.max(0.001, spawn.ttl);\n    const rawDistance = Math.min(spawn.speed * elapsed, spawn.range);\n    const predictedImpact = this.getActivePredictedImpact(projectile, now, rawDistance);\n    const visualImpact = projectile.visualImpact ?? projectile.impact;\n    const distance = visualImpact?.distance ?? predictedImpact?.distance ?? rawDistance;\n    const progress = Math.min(1, distance / spawn.range);\n    const x = visualImpact?.x ?? predictedImpact?.x ?? spawn.origin.x + spawn.direction.x * distance;\n    const y = visualImpact?.y ?? predictedImpact?.y ?? spawn.origin.y + spawn.direction.y * distance;\n    const impactElapsedMs = projectile.impactStartedAt !== undefined\n      ? Math.max(0, now - projectile.impactStartedAt)\n      : undefined;\n    return {\n      ...spawn,\n      x,\n      y,\n      angle: Math.atan2(spawn.direction.y, spawn.direction.x),\n      distance,\n      elapsed,\n      progress,\n      impact: projectile.impact,\n      impactElapsed: impactElapsedMs === undefined ? undefined : impactElapsedMs / 1000,\n      impactProgress: impactElapsedMs === undefined\n        ? undefined\n        : Math.min(1, impactElapsedMs / this.impactDurationMs),\n      destroyed: projectile.destroyAt !== undefined,\n      ttl,\n    };\n  }\n\n  private isWaitingForDelay(projectile: RuntimeProjectile, now: number): boolean {\n    const delayMs = (projectile.spawn.delay ?? 0) * 1000;\n    return now - projectile.createdAt - delayMs < 0;\n  }\n\n  private setPredictedImpact(projectile: RuntimeProjectile): void {\n    if (projectile.spawn.predictImpact === false) {\n      return;\n    }\n    const impact = this.predictionResolver?.(projectile.spawn);\n    if (!impact || !Number.isFinite(impact.x) || !Number.isFinite(impact.y)) {\n      return;\n    }\n    const distance = typeof impact.distance === \"number\" && Number.isFinite(impact.distance)\n      ? impact.distance\n      : Math.hypot(impact.x - projectile.spawn.origin.x, impact.y - projectile.spawn.origin.y);\n    if (!Number.isFinite(distance) || distance < 0 || distance > projectile.spawn.range) {\n      return;\n    }\n    projectile.predictedImpact = {\n      ...impact,\n      distance,\n    };\n  }\n\n  private getActivePredictedImpact(\n    projectile: RuntimeProjectile,\n    now: number,\n    rawDistance: number,\n  ): ClientProjectileImpact | undefined {\n    if (!projectile.predictedImpact || projectile.impact) {\n      return undefined;\n    }\n    const distance = projectile.predictedImpact.distance;\n    if (distance === undefined || rawDistance < distance) {\n      return undefined;\n    }\n    return projectile.predictedImpact;\n  }\n\n  private setImpact(projectile: RuntimeProjectile, impact: ClientProjectileImpact, now: number): void {\n    projectile.visualImpact = this.resolveVisualImpact(projectile, impact, now);\n    projectile.impact = impact;\n    projectile.predictedImpact = undefined;\n    projectile.impactStartedAt = projectile.impactStartedAt ?? now;\n    const impactDestroyAt = projectile.impactStartedAt + this.impactDurationMs;\n    projectile.destroyAt = Math.max(projectile.destroyAt ?? 0, impactDestroyAt);\n  }\n\n  private resolveVisualImpact(\n    projectile: RuntimeProjectile,\n    impact: ClientProjectileImpact,\n    now: number,\n  ): ClientProjectileImpact {\n    const predicted = projectile.predictedImpact;\n    if (!predicted || !this.isSameTarget(predicted, impact)) {\n      return impact;\n    }\n    const distance = predicted.distance;\n    if (distance === undefined) {\n      return impact;\n    }\n    const delayMs = (projectile.spawn.delay ?? 0) * 1000;\n    const elapsedMs = now - projectile.createdAt - delayMs;\n    if (elapsedMs < 0) {\n      return impact;\n    }\n    const rawDistance = Math.min(projectile.spawn.speed * (elapsedMs / 1000), projectile.spawn.range);\n    return rawDistance >= distance ? predicted : impact;\n  }\n\n  private isSameTarget(a: ClientProjectileImpact, b: ClientProjectileImpact): boolean {\n    return a.targetId !== undefined && a.targetId === b.targetId;\n  }\n\n  private touch(force = true): void {\n    if (force) {\n      this.version.update((value) => value + 1);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/Game/ProjectileManager.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Gui/Gui.d.ts

@@ -4,7 +4,7 @@ import { Subscription } from 'rxjs';
 interface GuiOptions {
     name?: string;
     id?: string;
-    component: any;
+    component?: any;
     display?: boolean;
     data?: any;
     /**
@@ -24,14 +24,18 @@ interface GuiOptions {
      * @default false
      */
     attachToSprite?: boolean;
+    /**
+     * Vue v4 compatibility flag. Prefer attachToSprite in v5 projects.
+     */
+    rpgAttachToSprite?: boolean;
 }
-interface GuiInstance {
+export interface GuiInstance {
     name: string;
     component: any;
     display: WritableSignal<boolean>;
     data: WritableSignal<any>;
     autoDisplay: boolean;
-    dependencies?: () => Signal[];
+    dependencies?: Signal[];
     subscription?: Subscription;
     attachToSprite?: boolean;
 }
@@ -113,7 +117,7 @@ export declare class RpgGui {
      * });
      * ```
      */
-    add(gui: GuiOptions): void;
+    add(gui: GuiOptions | any): void;
     registerOptimisticReducer(guiId: string, reducer: OptimisticReducer): void;
     /**
      * Get all attached GUI components (attachToSprite: true)
@@ -130,6 +134,8 @@ export declare class RpgGui {
      * ```
      */
     getAttachedGuis(): GuiInstance[];
+    getVueGuis(): GuiInstance[];
+    getAttachedVueGuis(): GuiInstance[];
     /**
      * Check if a player should display attached GUIs
      *
@@ -187,6 +193,13 @@ export declare class RpgGui {
      */
     hide(id: string): void;
     private isVueComponent;
+    private isVueComponentInstance;
+    private removeCanvasGui;
+    private removeVueGui;
+    private resolveComponent;
+    private resolveGuiId;
+    private resolveAttachToSprite;
+    private toGuiState;
     private clearPendingActions;
     private applyReducers;
     private applyOptimisticAction;

package/dist/Gui/Gui.js

@@ -1,12 +1,12 @@
-import { inject } from "../node_modules/.pnpm/@signe_di@2.9.0/node_modules/@signe/di/dist/index.js";
+import { inject } from "../node_modules/.pnpm/@signe_di@3.0.1/node_modules/@signe/di/dist/index.js";
 import { WebSocketToken } from "../services/AbstractSocket.js";
-import component from "../components/gui/dialogbox/index.ce.js";
-import component$1 from "../components/gui/shop/shop.ce.js";
-import component$2 from "../components/gui/save-load.ce.js";
-import component$3 from "../components/gui/menu/main-menu.ce.js";
-import component$4 from "../components/gui/notification/notification.ce.js";
-import component$5 from "../components/gui/title-screen.ce.js";
-import component$6 from "../components/gui/gameover.ce.js";
+import __ce_component from "../components/gui/dialogbox/index.ce.js";
+import __ce_component$1 from "../components/gui/shop/shop.ce.js";
+import __ce_component$2 from "../components/gui/save-load.ce.js";
+import __ce_component$3 from "../components/gui/menu/main-menu.ce.js";
+import __ce_component$4 from "../components/gui/notification/notification.ce.js";
+import __ce_component$5 from "../components/gui/title-screen.ce.js";
+import __ce_component$6 from "../components/gui/gameover.ce.js";
 import "../components/gui/index.js";
 import { signal } from "canvasengine";
 import { PrebuiltGui } from "@rpgjs/common";
@@ -86,32 +86,32 @@ var RpgGui = class {
 		this.webSocket = inject(context, WebSocketToken);
 		this.add({
 			name: "rpg-dialog",
-			component
+			component: __ce_component
 		});
 		this.add({
 			name: PrebuiltGui.MainMenu,
-			component: component$3
+			component: __ce_component$3
 		});
 		this.add({
 			name: PrebuiltGui.Shop,
-			component: component$1
+			component: __ce_component$1
 		});
 		this.add({
 			name: PrebuiltGui.Notification,
-			component: component$4,
+			component: __ce_component$4,
 			autoDisplay: true
 		});
 		this.add({
 			name: PrebuiltGui.Save,
-			component: component$2
+			component: __ce_component$2
 		});
 		this.add({
 			name: PrebuiltGui.TitleScreen,
-			component: component$5
+			component: __ce_component$5
 		});
 		this.add({
 			name: PrebuiltGui.Gameover,
-			component: component$6
+			component: __ce_component$6
 		});
 		this.registerOptimisticReducer(PrebuiltGui.MainMenu, mainMenuOptimisticReducer);
 	}
@@ -146,6 +146,7 @@ var RpgGui = class {
 	*/
 	_setVueGuiInstance(vueGuiInstance) {
 		this.vueGuiInstance = vueGuiInstance;
+		this._initializeVueComponents();
 	}
 	/**
 	* Notify VueGui about GUI state changes
@@ -156,35 +157,16 @@ var RpgGui = class {
 	* @param data - Component data
 	*/
 	_notifyVueGui(guiId, display, data = {}) {
-		if (this.vueGuiInstance && this.vueGuiInstance.vm) {
-			const extraGui = this.extraGuis.find((gui) => gui.name === guiId);
-			if (extraGui) {
-				this.vueGuiInstance.vm.gui[guiId] = {
-					name: guiId,
-					display,
-					data,
-					attachToSprite: extraGui.attachToSprite || false
-				};
-				this.vueGuiInstance.vm.gui = Object.assign({}, this.vueGuiInstance.vm.gui);
-			}
-		}
+		const extraGui = this.extraGuis.find((gui) => gui.name === guiId);
+		if (!extraGui) return;
+		this.vueGuiInstance?.updateGuiState?.(this.toGuiState(extraGui, display, data));
 	}
 	/**
 	* Initialize Vue components in the VueGui instance
 	* This should be called after VueGui is mounted
 	*/
 	_initializeVueComponents() {
-		if (this.vueGuiInstance && this.vueGuiInstance.vm) {
-			this.extraGuis.forEach((gui) => {
-				this.vueGuiInstance.vm.gui[gui.name] = {
-					name: gui.name,
-					display: gui.display(),
-					data: gui.data(),
-					attachToSprite: gui.attachToSprite || false
-				};
-			});
-			this.vueGuiInstance.vm.gui = Object.assign({}, this.vueGuiInstance.vm.gui);
-		}
+		this.vueGuiInstance?.initializeGuiStates?.(this.extraGuis.map((gui) => this.toGuiState(gui)));
 	}
 	guiInteraction(guiId, name, data) {
 		const clientActionId = globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random()}`;
@@ -244,24 +226,34 @@ var RpgGui = class {
 	* ```
 	*/
 	add(gui) {
-		const guiId = gui.name || gui.id;
+		const component = this.resolveComponent(gui);
+		const guiId = this.resolveGuiId(gui, component);
 		if (!guiId) throw new Error("GUI must have a name or id");
+		const attachToSprite = this.resolveAttachToSprite(gui, component);
 		const guiInstance = {
 			name: guiId,
-			component: gui.component,
+			component,
 			display: signal(gui.display || false),
 			data: signal(gui.data || {}),
 			autoDisplay: gui.autoDisplay || false,
 			dependencies: gui.dependencies ? gui.dependencies() : [],
-			attachToSprite: gui.attachToSprite || false
+			attachToSprite
 		};
-		if (typeof gui.component !== "function") {
-			guiInstance.component = gui;
-			this.extraGuis.push(guiInstance);
-			if (guiInstance.autoDisplay) this._notifyVueGui(guiId, true, gui.data || {});
+		if (this.isVueComponentInstance(guiInstance)) {
+			this.removeCanvasGui(guiId);
+			const existingIndex = this.extraGuis.findIndex((existing) => existing.name === guiId);
+			if (existingIndex >= 0) {
+				this.extraGuis[existingIndex].subscription?.unsubscribe();
+				this.extraGuis[existingIndex] = guiInstance;
+			} else this.extraGuis.push(guiInstance);
+			this._initializeVueComponents();
+			if (guiInstance.autoDisplay) this.display(guiId, gui.data);
+			else this._notifyVueGui(guiId, guiInstance.display(), guiInstance.data());
 			return;
 		}
+		this.removeVueGui(guiId);
 		this.gui()[guiId] = guiInstance;
+		this._initializeVueComponents();
 		if (guiInstance.autoDisplay && typeof gui.component === "function") this.display(guiId, gui.data);
 	}
 	registerOptimisticReducer(guiId, reducer) {
@@ -283,8 +275,13 @@ var RpgGui = class {
 	* ```
 	*/
 	getAttachedGuis() {
-		const allGuis = this.getAll();
-		return Object.values(allGuis).filter((gui) => gui.attachToSprite === true);
+		return Object.values(this.gui()).filter((gui) => gui.attachToSprite === true);
+	}
+	getVueGuis() {
+		return [...this.extraGuis];
+	}
+	getAttachedVueGuis() {
+		return this.extraGuis.filter((gui) => gui.attachToSprite === true);
 	}
 	/**
 	* Check if a player should display attached GUIs
@@ -358,7 +355,7 @@ var RpgGui = class {
 			guiInstance.subscription.unsubscribe();
 			guiInstance.subscription = void 0;
 		}
-		const deps = dependencies.length > 0 ? dependencies : guiInstance.dependencies ? guiInstance.dependencies() : [];
+		const deps = dependencies.length > 0 ? dependencies : guiInstance.dependencies ?? [];
 		if (deps.length > 0) {
 			guiInstance.subscription = combineLatest(deps.map((dependency) => dependency.observable)).subscribe((values) => {
 				if (values.every((value) => value !== void 0)) {
@@ -399,6 +396,39 @@ var RpgGui = class {
 	isVueComponent(id) {
 		return this.extraGuis.some((gui) => gui.name === id);
 	}
+	isVueComponentInstance(gui) {
+		return typeof gui.component !== "function";
+	}
+	removeCanvasGui(guiId) {
+		const current = this.gui();
+		if (!(guiId in current)) return;
+		const next = { ...current };
+		delete next[guiId];
+		this.gui.set(next);
+	}
+	removeVueGui(guiId) {
+		const removed = this.extraGuis.filter((existing) => existing.name === guiId);
+		removed.forEach((gui) => gui.subscription?.unsubscribe());
+		if (removed.length > 0) this.extraGuis = this.extraGuis.filter((existing) => existing.name !== guiId);
+	}
+	resolveComponent(gui) {
+		return gui?.component ?? gui;
+	}
+	resolveGuiId(gui, component) {
+		return gui?.name || gui?.id || component?.name || component?.__name;
+	}
+	resolveAttachToSprite(gui, component) {
+		return !!(gui?.attachToSprite || gui?.rpgAttachToSprite || component?.attachToSprite || component?.rpgAttachToSprite);
+	}
+	toGuiState(gui, display = gui.display(), data = gui.data()) {
+		return {
+			name: gui.name,
+			component: gui.component,
+			display,
+			data,
+			attachToSprite: gui.attachToSprite || false
+		};
+	}
 	clearPendingActions(guiId) {
 		this.pendingActions.delete(guiId);
 	}