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

package/CHANGELOG.md

@@ -0,0 +1,37 @@
+# @rpgjs/client
+
+## 5.0.0-beta.10
+
+### Patch Changes
+
+- Fix current-player control binding and canMove reads when values are provided by synced or reactive state.
+
+  Fix Vue GUI rendering for hidden fixed GUIs while keeping attached GUI targets updated.
+
+  - @rpgjs/server@5.0.0-beta.10
+
+## 5.0.0-beta.9
+
+### Major Changes
+
+- c456d25: beta.9
+
+### Patch Changes
+
+- Updated dependencies [c456d25]
+  - @rpgjs/common@5.0.0-beta.9
+  - @rpgjs/server@5.0.0-beta.9
+  - @rpgjs/ui-css@5.0.0-beta.9
+
+## 5.0.0-beta.8
+
+### Major Changes
+
+- 35e7fa4: beta.8
+
+### Patch Changes
+
+- Updated dependencies [35e7fa4]
+  - @rpgjs/common@5.0.0-beta.8
+  - @rpgjs/server@5.0.0-beta.8
+  - @rpgjs/ui-css@5.0.0-beta.8

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2026 by Samuel Ronce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/Game/AnimationManager.d.ts

@@ -0,0 +1,8 @@
+import { RpgCommonPlayer } from '@rpgjs/common';
+export declare class AnimationManager {
+    current: import('canvasengine').WritableArraySignal<any[]>;
+    displayEffect(params: any, player: RpgCommonPlayer | {
+        x: number;
+        y: number;
+    }): Promise<void>;
+}

package/dist/Game/AnimationManager.js

@@ -0,0 +1,35 @@
+import { signal } from "canvasengine";
+import { generateUID } from "@rpgjs/common";
+//#region src/Game/AnimationManager.ts
+var AnimationManager = class {
+	constructor() {
+		this.current = signal([]);
+	}
+	displayEffect(params, player) {
+		const id = generateUID();
+		const effectParams = params ?? {};
+		return new Promise((resolve) => {
+			let finished = false;
+			const finish = (data) => {
+				if (finished) return;
+				finished = true;
+				const index = this.current().findIndex((value) => value.id === id);
+				if (index !== -1) this.current().splice(index, 1);
+				effectParams.onFinish?.(data);
+				resolve();
+			};
+			this.current().push({
+				...effectParams,
+				id,
+				x: player.x,
+				y: player.y,
+				object: player,
+				onFinish: finish
+			});
+		});
+	}
+};
+//#endregion
+export { AnimationManager };
+
+//# sourceMappingURL=AnimationManager.js.map

package/dist/Game/AnimationManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationManager.js","names":[],"sources":["../../src/Game/AnimationManager.ts"],"sourcesContent":["import { generateUID, RpgCommonPlayer } from \"@rpgjs/common\";\nimport { signal } from \"canvasengine\";\n\nexport class AnimationManager {\n  current = signal<any[]>([]);\n\n  displayEffect(params: any, player: RpgCommonPlayer | { x: number, y: number }): Promise<void> {\n    const id = generateUID();\n    const effectParams = params ?? {};\n    return new Promise<void>((resolve) => {\n      let finished = false;\n      const finish = (data?: any) => {\n        if (finished) return;\n        finished = true;\n        const index = this.current().findIndex((value) => value.id === id);\n        if (index !== -1) {\n          this.current().splice(index, 1);\n        }\n        effectParams.onFinish?.(data);\n        resolve();\n      };\n\n      this.current().push({\n        ...effectParams,\n        id,\n        x: player.x,\n        y: player.y,\n        object: player,\n        onFinish: finish,\n      });\n    });\n  }\n}\n"],"mappings":";;;AAGA,IAAa,mBAAb,MAA8B;;iBAClB,OAAc,CAAC,CAAC;;CAE1B,cAAc,QAAa,QAAmE;EAC5F,MAAM,KAAK,YAAY;EACvB,MAAM,eAAe,UAAU,CAAC;EAChC,OAAO,IAAI,SAAe,YAAY;GACpC,IAAI,WAAW;GACf,MAAM,UAAU,SAAe;IAC7B,IAAI,UAAU;IACd,WAAW;IACX,MAAM,QAAQ,KAAK,QAAQ,EAAE,WAAW,UAAU,MAAM,OAAO,EAAE;IACjE,IAAI,UAAU,IACZ,KAAK,QAAQ,EAAE,OAAO,OAAO,CAAC;IAEhC,aAAa,WAAW,IAAI;IAC5B,QAAQ;GACV;GAEA,KAAK,QAAQ,EAAE,KAAK;IAClB,GAAG;IACH;IACA,GAAG,OAAO;IACV,GAAG,OAAO;IACV,QAAQ;IACR,UAAU;GACZ,CAAC;EACH,CAAC;CACH;AACF"}

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

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

package/dist/Game/Event.d.ts

@@ -1,4 +1,4 @@
 import { RpgClientObject } from './Object';
 export declare class RpgClientEvent extends RpgClientObject {
-    type: string;
+    _type: string;
 }

package/dist/Game/Event.js

@@ -0,0 +1,12 @@
+import { RpgClientObject } from "./Object.js";
+//#region src/Game/Event.ts
+var RpgClientEvent = class extends RpgClientObject {
+	constructor(..._args) {
+		super(..._args);
+		this._type = "event";
+	}
+};
+//#endregion
+export { RpgClientEvent };
+
+//# sourceMappingURL=Event.js.map

package/dist/Game/Event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.js","names":[],"sources":["../../src/Game/Event.ts"],"sourcesContent":["import { RpgClientObject } from \"./Object\"; \n\nexport class RpgClientEvent extends RpgClientObject {\n    _type = 'event'\n}   "],"mappings":";;AAEA,IAAa,iBAAb,cAAoC,gBAAgB;;;eACxC;;AACZ"}

package/dist/Game/Map.d.ts

@@ -1,7 +1,36 @@
-import { RpgCommonMap } from '@rpgjs/common';
+import { RpgCommonMap, LightSpot, LightingState, WeatherState, MapPhysicsInitContext, MapPhysicsEntityContext } from '@rpgjs/common';
 import { RpgClientPlayer } from './Player';
 import { RpgClientEvent } from './Event';
-export declare class RpgClientMap extends RpgCommonMap<RpgClientPlayer> {
+import { RpgClientEngine } from '../RpgClientEngine';
+export declare class RpgClientMap extends RpgCommonMap<any> {
+    engine: RpgClientEngine;
     players: import('canvasengine').WritableObjectSignal<Record<string, RpgClientPlayer>>;
     events: import('canvasengine').WritableObjectSignal<Record<string, RpgClientEvent>>;
+    currentPlayer: import('canvasengine').ComputedSignal<RpgClientPlayer>;
+    weatherState: import('canvasengine').WritableSignal<WeatherState | null>;
+    localWeatherOverride: import('canvasengine').WritableSignal<WeatherState | null>;
+    lightingState: import('canvasengine').WritableSignal<LightingState | null>;
+    localLightSpots: import('canvasengine').WritableObjectSignal<Record<string, LightSpot>>;
+    weather: import('canvasengine').ComputedSignal<WeatherState | null>;
+    lighting: import('canvasengine').ComputedSignal<LightingState | null>;
+    private manualClientPhysicsTick;
+    private readonly isTestEnvironment;
+    constructor();
+    configureClientPrediction(enabled: boolean): void;
+    getCurrentPlayer(): RpgClientPlayer;
+    reset(force?: boolean): void;
+    getWeather(): WeatherState | null;
+    setLocalWeather(next: WeatherState | null): void;
+    clearLocalWeather(): void;
+    getLighting(): LightingState | null;
+    addLightSpot(id: string, spot: LightSpot): void;
+    patchLightSpot(id: string, patch: Partial<LightSpot>): void;
+    removeLightSpot(id: string): void;
+    clearLightSpots(): void;
+    stepClientPhysics(deltaMs: number): number;
+    stepPredictionTick(): void;
+    protected emitPhysicsInit(context: MapPhysicsInitContext): void;
+    protected emitPhysicsEntityAdd(context: MapPhysicsEntityContext): void;
+    protected emitPhysicsEntityRemove(context: MapPhysicsEntityContext): void;
+    protected emitPhysicsReset(): void;
 }

package/dist/Game/Map.js

@@ -0,0 +1,138 @@
+import { inject } from "../core/inject.js";
+import { sync, users } from "../node_modules/.pnpm/@signe_sync@3.0.1/node_modules/@signe/sync/dist/index.js";
+import { RpgClientPlayer } from "./Player.js";
+import { RpgClientEvent } from "./Event.js";
+import { __decorateMetadata } from "../_virtual/_@oxc-project_runtime@0.130.0/helpers/decorateMetadata.js";
+import { __decorate } from "../_virtual/_@oxc-project_runtime@0.130.0/helpers/decorate.js";
+import { RpgClientEngine } from "../RpgClientEngine.js";
+import { computed, signal } from "canvasengine";
+import { RpgCommonMap, cloneLightingState, normalizeLightingState } from "@rpgjs/common";
+//#region src/Game/Map.ts
+var RpgClientMap = class extends RpgCommonMap {
+	constructor() {
+		super();
+		this.engine = inject(RpgClientEngine);
+		this.players = signal({});
+		this.events = signal({});
+		this.currentPlayer = computed(() => this.players()[this.engine.playerIdSignal()]);
+		this.weatherState = signal(null);
+		this.localWeatherOverride = signal(null);
+		this.lightingState = signal(null);
+		this.localLightSpots = signal({});
+		this.weather = computed(() => {
+			const local = this.localWeatherOverride();
+			const state = this.weatherState();
+			return local ?? state;
+		});
+		this.lighting = computed(() => {
+			const state = cloneLightingState(this.lightingState());
+			const localSpots = Object.entries(this.localLightSpots()).map(([id, spot]) => ({
+				...spot,
+				id: spot.id ?? id
+			}));
+			if (!state && localSpots.length === 0) return null;
+			const next = { ...state ?? {} };
+			if (!state?.ambient) delete next.ambient;
+			next.spots = [...state?.spots ?? [], ...localSpots];
+			return next;
+		});
+		this.manualClientPhysicsTick = false;
+		const testGlobal = globalThis;
+		const isTest = testGlobal.process?.env?.TEST === "true" || testGlobal.__RPGJS_TEST__ === true;
+		this.isTestEnvironment = isTest;
+		if (isTest) this.autoTickEnabled = false;
+	}
+	configureClientPrediction(enabled) {
+		this.manualClientPhysicsTick = enabled;
+		this.autoTickEnabled = enabled ? false : !this.isTestEnvironment;
+	}
+	getCurrentPlayer() {
+		return this.currentPlayer();
+	}
+	reset(force = false) {
+		const currentPlayerId = this.engine.playerIdSignal();
+		const currentPlayer = !force && currentPlayerId ? this.players()[currentPlayerId] : void 0;
+		this.players.set(currentPlayerId && currentPlayer ? { [currentPlayerId]: currentPlayer } : {});
+		this.events.set({});
+		this.weatherState.set(null);
+		this.localWeatherOverride.set(null);
+		this.lightingState.set(null);
+		this.localLightSpots.set({});
+		this.clearPhysic();
+	}
+	getWeather() {
+		return this.weather();
+	}
+	setLocalWeather(next) {
+		this.localWeatherOverride.set(next);
+	}
+	clearLocalWeather() {
+		this.localWeatherOverride.set(null);
+	}
+	getLighting() {
+		return this.lighting();
+	}
+	addLightSpot(id, spot) {
+		const nextSpot = normalizeLightingState({ spots: [{
+			...spot,
+			id
+		}] })?.spots?.[0];
+		if (!nextSpot) return;
+		this.localLightSpots.update((spots) => ({
+			...spots,
+			[id]: nextSpot
+		}));
+	}
+	patchLightSpot(id, patch) {
+		this.localLightSpots.update((spots) => {
+			const current = spots[id];
+			if (!current) return spots;
+			return {
+				...spots,
+				[id]: {
+					...current,
+					...patch,
+					id,
+					x: patch.x ?? current.x,
+					y: patch.y ?? current.y
+				}
+			};
+		});
+	}
+	removeLightSpot(id) {
+		this.localLightSpots.update((spots) => {
+			if (!(id in spots)) return spots;
+			const next = { ...spots };
+			delete next[id];
+			return next;
+		});
+	}
+	clearLightSpots() {
+		this.localLightSpots.set({});
+	}
+	stepClientPhysics(deltaMs) {
+		if (!this.manualClientPhysicsTick) return 0;
+		return this.nextTick(deltaMs);
+	}
+	stepPredictionTick() {
+		this.forceSingleTick();
+	}
+	emitPhysicsInit(context) {
+		this.engine?.emitSceneMapHook?.("onPhysicsInit", this, context);
+	}
+	emitPhysicsEntityAdd(context) {
+		this.engine?.emitSceneMapHook?.("onPhysicsEntityAdd", this, context);
+	}
+	emitPhysicsEntityRemove(context) {
+		this.engine?.emitSceneMapHook?.("onPhysicsEntityRemove", this, context);
+	}
+	emitPhysicsReset() {
+		this.engine?.emitSceneMapHook?.("onPhysicsReset", this);
+	}
+};
+__decorate([users(RpgClientPlayer), __decorateMetadata("design:type", Object)], RpgClientMap.prototype, "players", void 0);
+__decorate([sync(RpgClientEvent), __decorateMetadata("design:type", Object)], RpgClientMap.prototype, "events", void 0);
+//#endregion
+export { RpgClientMap };
+
+//# sourceMappingURL=Map.js.map

package/dist/Game/Map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Map.js","names":[],"sources":["../../src/Game/Map.ts"],"sourcesContent":["import {\n  RpgCommonMap,\n  cloneLightingState,\n  normalizeLightingState,\n  type LightSpot,\n  type LightingState,\n  type WeatherState,\n  type MapPhysicsInitContext,\n  type MapPhysicsEntityContext,\n} from \"@rpgjs/common\";\nimport { sync, users } from \"@signe/sync\";\nimport { RpgClientPlayer } from \"./Player\";\nimport { Signal, signal, computed, effect } from \"canvasengine\";\nimport { RpgClientEvent } from \"./Event\";\nimport { RpgClientEngine } from \"../RpgClientEngine\";\nimport { inject } from \"../core/inject\";\n\ntype TestGlobalScope = typeof globalThis & {\n  process?: {\n    env?: {\n      TEST?: string;\n    };\n  };\n  __RPGJS_TEST__?: boolean;\n};\n\nexport class RpgClientMap extends RpgCommonMap<any> {\n  engine: RpgClientEngine = inject(RpgClientEngine)\n  @users(RpgClientPlayer) players = signal<Record<string, RpgClientPlayer>>({});\n  @sync(RpgClientEvent) events = signal<Record<string, RpgClientEvent>>({});\n  currentPlayer = computed(() => this.players()[this.engine.playerIdSignal()!])\n  weatherState = signal<WeatherState | null>(null);\n  localWeatherOverride = signal<WeatherState | null>(null);\n  lightingState = signal<LightingState | null>(null);\n  localLightSpots = signal<Record<string, LightSpot>>({});\n  weather = computed<WeatherState | null>(() => {\n    const local = this.localWeatherOverride() \n    const state = this.weatherState()\n    return local ?? state\n  });\n  lighting = computed<LightingState | null>(() => {\n    const state = cloneLightingState(this.lightingState());\n    const localSpots = Object.entries(this.localLightSpots()).map(([id, spot]) => ({\n      ...spot,\n      id: spot.id ?? id,\n    }));\n\n    if (!state && localSpots.length === 0) {\n      return null;\n    }\n\n    const next: LightingState = { ...(state ?? {}) };\n    if (!state?.ambient) {\n      delete next.ambient;\n    }\n    next.spots = [\n      ...(state?.spots ?? []),\n      ...localSpots,\n    ];\n    return next;\n  });\n  private manualClientPhysicsTick = false;\n  private readonly isTestEnvironment: boolean;\n\n  constructor() {\n    super();\n    // Détecter l'environnement de test\n    const testGlobal = globalThis as TestGlobalScope;\n    const isTest = testGlobal.process?.env?.TEST === 'true'\n      || testGlobal.__RPGJS_TEST__ === true;\n    this.isTestEnvironment = isTest;\n    if (isTest) {\n      this.autoTickEnabled = false;\n    }\n  }\n\n  configureClientPrediction(enabled: boolean): void {\n    this.manualClientPhysicsTick = enabled;\n    this.autoTickEnabled = enabled ? false : !this.isTestEnvironment;\n  }\n\n  getCurrentPlayer() {\n    return this.currentPlayer()\n  }\n\n  reset(force = false) {\n    const currentPlayerId = this.engine.playerIdSignal();\n    const currentPlayer = !force && currentPlayerId\n      ? this.players()[currentPlayerId]\n      : undefined;\n\n    this.players.set(\n      currentPlayerId && currentPlayer ? { [currentPlayerId]: currentPlayer } : {}\n    );\n    this.events.set({})\n    this.weatherState.set(null);\n    this.localWeatherOverride.set(null);\n    this.lightingState.set(null);\n    this.localLightSpots.set({});\n    this.clearPhysic()\n  }\n\n  getWeather(): WeatherState | null {\n    return this.weather();\n  }\n\n  setLocalWeather(next: WeatherState | null): void {\n    this.localWeatherOverride.set(next);\n  }\n\n  clearLocalWeather(): void {\n    this.localWeatherOverride.set(null);\n  }\n\n  getLighting(): LightingState | null {\n    return this.lighting();\n  }\n\n  addLightSpot(id: string, spot: LightSpot): void {\n    const normalized = normalizeLightingState({ spots: [{ ...spot, id }] });\n    const nextSpot = normalized?.spots?.[0];\n    if (!nextSpot) {\n      return;\n    }\n    this.localLightSpots.update((spots) => ({\n      ...spots,\n      [id]: nextSpot,\n    }));\n  }\n\n  patchLightSpot(id: string, patch: Partial<LightSpot>): void {\n    this.localLightSpots.update((spots) => {\n      const current = spots[id];\n      if (!current) {\n        return spots;\n      }\n      return {\n        ...spots,\n        [id]: {\n          ...current,\n          ...patch,\n          id,\n          x: patch.x ?? current.x,\n          y: patch.y ?? current.y,\n        },\n      };\n    });\n  }\n\n  removeLightSpot(id: string): void {\n    this.localLightSpots.update((spots) => {\n      if (!(id in spots)) {\n        return spots;\n      }\n      const next = { ...spots };\n      delete next[id];\n      return next;\n    });\n  }\n\n  clearLightSpots(): void {\n    this.localLightSpots.set({});\n  }\n\n  stepClientPhysics(deltaMs: number): number {\n    if (!this.manualClientPhysicsTick) {\n      return 0;\n    }\n    return this.nextTick(deltaMs);\n  }\n\n  stepPredictionTick(): void {\n    this.forceSingleTick();\n  }\n\n  protected emitPhysicsInit(context: MapPhysicsInitContext): void {\n    this.engine?.emitSceneMapHook?.(\"onPhysicsInit\", this, context);\n  }\n\n  protected emitPhysicsEntityAdd(context: MapPhysicsEntityContext): void {\n    this.engine?.emitSceneMapHook?.(\"onPhysicsEntityAdd\", this, context);\n  }\n\n  protected emitPhysicsEntityRemove(context: MapPhysicsEntityContext): void {\n    this.engine?.emitSceneMapHook?.(\"onPhysicsEntityRemove\", this, context);\n  }\n\n  protected emitPhysicsReset(): void {\n    this.engine?.emitSceneMapHook?.(\"onPhysicsReset\", this);\n  }\n}\n"],"mappings":"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"}

package/dist/Game/Object.d.ts

@@ -0,0 +1,189 @@
+import { Hooks, RpgCommonPlayer } from '@rpgjs/common';
+import { Trigger } from 'canvasengine';
+import { RpgClientEngine } from '../RpgClientEngine';
+type Frame = {
+    x: number;
+    y: number;
+    ts: number;
+};
+type AnimationRestoreOptions = {
+    restoreAnimationName?: string;
+    restoreGraphics?: any[];
+    timeoutMs?: number;
+};
+type FlashType = 'alpha' | 'tint' | 'both';
+type FlashOptions = {
+    type?: FlashType;
+    duration?: number;
+    cycles?: number;
+    alpha?: number;
+    tint?: number | string;
+};
+type FlashTriggerOptions = Omit<FlashOptions, "tint"> & {
+    tint: number;
+};
+type ConfigurableTrigger<T> = Omit<Trigger<T>, "start"> & {
+    start(config?: T): Promise<void>;
+};
+export declare abstract class RpgClientObject extends RpgCommonPlayer {
+    abstract _type: string;
+    emitParticleTrigger: Trigger<any>;
+    particleName: import('canvasengine').WritableSignal<string>;
+    animationCurrentIndex: import('canvasengine').WritableSignal<number>;
+    animationIsPlaying: import('canvasengine').WritableSignal<boolean>;
+    _param: import('canvasengine').WritableObjectSignal<{}>;
+    frames: Frame[];
+    graphicsSignals: import('canvasengine').WritableArraySignal<any[]>;
+    flashTrigger: ConfigurableTrigger<FlashTriggerOptions>;
+    private animationRestoreState?;
+    constructor();
+    /**
+     * Access the shared client hook registry.
+     *
+     * @returns The hook service used to register and trigger client-side hooks.
+     */
+    get hooks(): Hooks;
+    /**
+     * Access the current client engine instance.
+     *
+     * @returns The active {@link RpgClientEngine} instance.
+     */
+    get engine(): RpgClientEngine<unknown>;
+    private animationSubscription?;
+    private animationResetTimeout?;
+    private animationWaitResolve?;
+    private clearAnimationControls;
+    private resolveAnimationWait;
+    private finishTemporaryAnimation;
+    /**
+     * Trigger a flash animation on this sprite
+     *
+     * This method triggers a flash effect using CanvasEngine's flash directive.
+     * The flash can be configured with various options including type (alpha, tint, or both),
+     * duration, cycles, and color.
+     *
+     * ## Design
+     *
+     * The flash uses a trigger system that is connected to the flash directive in the
+     * character component. This allows for flexible configuration and can be triggered
+     * from both server events and client-side code.
+     *
+     * @param options - Flash configuration options
+     * @param options.type - Type of flash effect: 'alpha' (opacity), 'tint' (color), or 'both' (default: 'alpha')
+     * @param options.duration - Duration of the flash animation in milliseconds (default: 300)
+     * @param options.cycles - Number of flash cycles (flash on/off) (default: 1)
+     * @param options.alpha - Alpha value when flashing, from 0 to 1 (default: 0.3)
+     * @param options.tint - Tint color when flashing as hex value or color name (default: 0xffffff - white)
+     *
+     * @example
+     * ```ts
+     * // Simple flash with default settings (alpha flash)
+     * player.flash();
+     *
+     * // Flash with red tint
+     * player.flash({ type: 'tint', tint: 0xff0000 });
+     *
+     * // Flash with both alpha and tint
+     * player.flash({
+     *   type: 'both',
+     *   alpha: 0.5,
+     *   tint: 0xff0000,
+     *   duration: 200,
+     *   cycles: 2
+     * });
+     *
+     * // Quick damage flash
+     * player.flash({
+     *   type: 'tint',
+     *   tint: 0xff0000,
+     *   duration: 150,
+     *   cycles: 1
+     * });
+     * ```
+     */
+    flash(options?: FlashOptions): void;
+    /**
+     * Reset animation state when animation changes externally
+     *
+     * This method should be called when the animation changes due to movement
+     * or other external factors to ensure the animation system doesn't get stuck
+     *
+     * @example
+     * ```ts
+     * // Reset when player starts moving
+     * player.resetAnimationState();
+     * ```
+     */
+    resetAnimationState(): void;
+    /**
+     * Set a custom animation for a specific number of times
+     *
+     * Plays a custom animation for the specified number of repetitions.
+     * The animation system prevents overlapping animations and automatically
+     * returns to the previous animation when complete.
+     *
+     * @param animationName - Name of the animation to play
+     * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)
+     * @param options - Restore and timeout options
+     * @returns A promise resolved when a finite animation finishes, is interrupted, or times out
+     *
+     * @example
+     * ```ts
+     * // Play attack animation 3 times
+     * await player.setAnimation('attack', 3);
+     *
+     * // Play continuous spell animation
+     * player.setAnimation('spell');
+     * ```
+     */
+    setAnimation(animationName: string, nbTimes?: number, options?: AnimationRestoreOptions): Promise<void>;
+    /**
+     * Set a custom animation with temporary graphic change
+     *
+     * Plays a custom animation for the specified number of repetitions and temporarily
+     * changes the player's graphic (sprite sheet) during the animation. The graphic
+     * is automatically reset when the animation finishes.
+     *
+     * @param animationName - Name of the animation to play
+     * @param graphic - The graphic(s) to temporarily use during the animation
+     * @param nbTimes - Number of times to repeat the animation (default: Infinity for continuous)
+     * @param options - Restore and timeout options
+     * @returns A promise resolved when a finite animation finishes, is interrupted, or times out
+     *
+     * @example
+     * ```ts
+     * // Play attack animation with temporary graphic change
+     * await player.setAnimation('attack', 'hero_attack', 3);
+     * ```
+     */
+    setAnimation(animationName: string, graphic?: string | string[], nbTimes?: number, options?: AnimationRestoreOptions): Promise<void>;
+    /**
+     * Display a registered component animation effect on this object.
+     *
+     * @param id - Identifier of the component animation to play.
+     * @param params - Parameters forwarded to the animation effect.
+     * @returns A promise resolved when the animation component calls `onFinish`.
+     */
+    showComponentAnimation(id: string, params: any): Promise<void>;
+    /**
+     * Display a registered spritesheet animation effect on this object.
+     *
+     * @param graphic - Identifier of the spritesheet to use.
+     * @param animationName - Name of the animation inside the spritesheet.
+     * @returns A promise resolved when the animation component calls `onFinish`.
+     */
+    showAnimation(graphic: string, animationName?: string): Promise<void>;
+    /**
+     * Check whether this client object represents an event.
+     *
+     * @returns `true` if the object type is `event`, otherwise `false`.
+     */
+    isEvent(): boolean;
+    /**
+     * Check whether this client object represents a player.
+     *
+     * @returns `true` if the object type is `player`, otherwise `false`.
+     */
+    isPlayer(): boolean;
+}
+export {};