@rpgjs/client 5.0.0-alpha.8 → 5.0.0-beta.1

package/dist/services/standalone.js

@@ -0,0 +1,168 @@
+import { AbstractWebsocket, WebSocketToken } from "./AbstractSocket.js";
+import { provideSaveClient } from "./save.js";
+import { RpgGui } from "../Gui/Gui.js";
+import { RpgClientEngine } from "../RpgClientEngine.js";
+import { ClientIo, ServerIo } from "../node_modules/.pnpm/@signe_room@2.9.0/node_modules/@signe/room/dist/index.js";
+import { provideKeyboardControls } from "./keyboardControls.js";
+import { UpdateMapService, UpdateMapToken } from "@rpgjs/common";
+//#region src/services/standalone.ts
+var BridgeWebsocket = class extends AbstractWebsocket {
+	constructor(context, server, options = {}) {
+		super(context);
+		this.context = context;
+		this.server = server;
+		this.pendingOn = [];
+		this.rooms = {
+			partyFn: async (roomId) => {
+				this.room = new ServerIo(roomId, this.rooms);
+				const server = new this.server(this.room);
+				await server.onStart();
+				await server.subRoom.onStart();
+				this.context.set("server", server);
+				return server;
+			},
+			env: {}
+		};
+		this.rooms.env = options.env || {};
+		this.room = new ServerIo("lobby-1", this.rooms);
+	}
+	async connection(listeners) {
+		this.serverInstance = new this.server(this.room);
+		await this.serverInstance.onStart();
+		await this.serverInstance.subRoom.onStart();
+		this.context.set("server", this.serverInstance);
+		return this._connection(listeners);
+	}
+	async _connection(listeners) {
+		this.serverInstance = this.context.get("server");
+		this.socket = new ClientIo(this.serverInstance, "player-client-id");
+		const url = new URL("http://localhost");
+		const request = new Request(url.toString(), {
+			method: "GET",
+			headers: { "Content-Type": "application/json" }
+		});
+		listeners?.(this.socket);
+		await this.serverInstance.onConnect(this.socket.conn, { request });
+		this.room.clients.set(this.socket.id, this.socket);
+		this.pendingOn.forEach(({ event, callback }) => this.socket.addEventListener(event, callback));
+		this.pendingOn = [];
+		return this.socket;
+	}
+	on(key, callback) {
+		const handler = (event) => {
+			const object = JSON.parse(event);
+			if (object.type === key) callback(object.value);
+		};
+		if (!this.socket) {
+			this.pendingOn.push({
+				event: "message",
+				callback: handler
+			});
+			return;
+		}
+		this.socket.addEventListener("message", handler);
+	}
+	off(event, callback) {
+		if (!this.socket) return;
+		this.socket.removeEventListener(event, callback);
+	}
+	emit(event, data) {
+		this.socket.send({
+			action: event,
+			value: data
+		});
+	}
+	/**
+	* Update underlying connection properties before a reconnect
+	*
+	* Design
+	* - Dynamically register a factory for the requested room to ensure a fresh server instance
+	* - Swap the internal ServerIo to target the new room
+	*
+	* @param params - Properties to update
+	* @param params.room - The target room id (e.g. `map-simplemap2`)
+	*
+	* @example
+	* ```ts
+	* websocket.updateProperties({ room: 'map-simplemap2' })
+	* await websocket.reconnect()
+	* ```
+	*/
+	updateProperties(_params) {}
+	/**
+	* Reconnect the client to the current Party room
+	*
+	* Design
+	* - Must be called after `updateProperties()` when switching rooms
+	* - Rebuilds the client <-> server bridge and re-triggers connection listeners
+	*
+	* @param listeners - Optional callback to re-bind event handlers on the new socket
+	*
+	* @example
+	* ```ts
+	* websocket.updateProperties({ room: 'map-dungeon' })
+	* await websocket.reconnect((socket) => {
+	*   // re-bind events here
+	* })
+	* ```
+	*/
+	async reconnect(listeners) {
+		await this._connection((socket) => {
+			listeners?.(socket);
+		});
+	}
+	getServer() {
+		return this.serverInstance;
+	}
+	getSocket() {
+		return this.socket;
+	}
+};
+var UpdateMapStandaloneService = class extends UpdateMapService {
+	/**
+	* Update the current room map data on the server side
+	*
+	* Design
+	* - Uses the in-memory server instance stored in context (standalone mode)
+	* - Builds a local HTTP-like request to the current Party room endpoint
+	*
+	* @param map - The map payload to apply on the server
+	*
+	* @example
+	* ```ts
+	* await updateMapService.update({ width: 1024, height: 768, events: [] })
+	* ```
+	*/
+	async update(map) {
+		this.server = this.context.get("server");
+		const req = {
+			url: `http://localhost/parties/main/${this.server?.room?.id ?? "lobby-1"}/map/update`,
+			method: "POST",
+			headers: new Headers({}),
+			json: async () => {
+				return map;
+			}
+		};
+		await this.server.onRequest(req);
+	}
+};
+function provideRpg(server, options = {}) {
+	return [
+		{
+			provide: WebSocketToken,
+			useFactory: (context) => new BridgeWebsocket(context, server, options)
+		},
+		{
+			provide: UpdateMapToken,
+			useClass: UpdateMapStandaloneService
+		},
+		provideKeyboardControls(),
+		provideSaveClient(),
+		RpgGui,
+		RpgClientEngine
+	];
+}
+//#endregion
+export { provideRpg };
+
+//# sourceMappingURL=standalone.js.map

package/dist/services/standalone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.js","names":[],"sources":["../../src/services/standalone.ts"],"sourcesContent":["import { AbstractWebsocket, SocketUpdateProperties, WebSocketToken } from \"./AbstractSocket\";\nimport { ClientIo, ServerIo } from \"@signe/room\";\nimport { Context } from \"@signe/di\";\nimport { RpgClientEngine } from \"../RpgClientEngine\";\nimport { UpdateMapService, UpdateMapToken } from \"@rpgjs/common\";\nimport { LoadMapToken } from \"./loadMap\";\nimport { RpgGui } from \"../Gui/Gui\";\nimport { provideKeyboardControls } from \"./keyboardControls\";\nimport { provideSaveClient } from \"./save\";\n\ntype ServerIo = any;\ntype ClientIo = any;\n\ninterface StandaloneOptions {\n  env?: Record<string, any>;\n}\n\nclass BridgeWebsocket extends AbstractWebsocket {\n  private room: ServerIo;\n  private socket: ClientIo;\n  private pendingOn: Array<{ event: string; callback: (data: any) => void }> = [];\n  private rooms = {\n    partyFn: async (roomId: string) => {\n      this.room = new ServerIo(roomId, this.rooms);\n      const server = new this.server(this.room)\n      await server.onStart();\n      await server.subRoom.onStart()\n      this.context.set('server', server)\n      return server\n    },\n    env: {}\n  }\n  private serverInstance: any;\n\n  constructor(protected context: Context, private server: any, options: StandaloneOptions = {}) {\n    super(context);\n    // fake room\n    this.rooms.env = options.env || {};\n    this.room = new ServerIo(\"lobby-1\", this.rooms);\n  }\n\n  async connection(listeners?: (data: any) => void) {\n    this.serverInstance = new this.server(this.room);\n    await this.serverInstance.onStart();\n    await this.serverInstance.subRoom.onStart()\n    this.context.set('server', this.serverInstance)\n    return this._connection(listeners)\n  }\n\n  private async _connection(listeners?: (data: any) => void) {\n    this.serverInstance = this.context.get('server')\n    this.socket = new ClientIo(this.serverInstance, 'player-client-id');\n    const url = new URL('http://localhost')\n    const request = new Request(url.toString(), {\n      method: 'GET',\n      headers: {\n        'Content-Type': 'application/json'\n      }\n    })\n    listeners?.(this.socket)\n    await this.serverInstance.onConnect(this.socket.conn as any, { request } as any);\n    this.room.clients.set(this.socket.id, this.socket);\n    this.pendingOn.forEach(({ event, callback }) => this.socket.addEventListener(event, callback));\n    this.pendingOn = [];\n    return this.socket\n  }\n\n  on(key: string, callback: (data: any) => void) {\n    const handler = (event) => {\n      const object = JSON.parse(event);\n      if (object.type === key) {\n        callback(object.value);\n      }\n    };\n    if (!this.socket) {\n      this.pendingOn.push({ event: \"message\", callback: handler });\n      return;\n    }\n    this.socket.addEventListener(\"message\", handler);\n  }\n\n  off(event: string, callback: (data: any) => void) {\n    if (!this.socket) return;\n    this.socket.removeEventListener(event, callback);\n  }\n\n  emit(event: string, data: any) {\n    this.socket.send({\n      action: event,\n      value: data,\n    });\n  }\n\n  /**\n   * Update underlying connection properties before a reconnect\n   *\n   * Design\n   * - Dynamically register a factory for the requested room to ensure a fresh server instance\n   * - Swap the internal ServerIo to target the new room\n   *\n   * @param params - Properties to update\n   * @param params.room - The target room id (e.g. `map-simplemap2`)\n   *\n   * @example\n   * ```ts\n   * websocket.updateProperties({ room: 'map-simplemap2' })\n   * await websocket.reconnect()\n   * ```\n   */\n  updateProperties(_params: SocketUpdateProperties) {\n    // empty\n  }\n\n  /**\n   * Reconnect the client to the current Party room\n   *\n   * Design\n   * - Must be called after `updateProperties()` when switching rooms\n   * - Rebuilds the client <-> server bridge and re-triggers connection listeners\n   *\n   * @param listeners - Optional callback to re-bind event handlers on the new socket\n   *\n   * @example\n   * ```ts\n   * websocket.updateProperties({ room: 'map-dungeon' })\n   * await websocket.reconnect((socket) => {\n   *   // re-bind events here\n   * })\n   * ```\n   */\n  async reconnect(listeners?: (data: any) => void): Promise<void> {\n    await this._connection((socket) => {\n      listeners?.(socket)\n    })\n  }\n\n  getServer() {\n    return this.serverInstance\n  }\n\n  getSocket() {\n    return this.socket\n  }\n}\n\nclass UpdateMapStandaloneService extends UpdateMapService {\n  private server: any;\n\n  /**\n   * Update the current room map data on the server side\n   *\n   * Design\n   * - Uses the in-memory server instance stored in context (standalone mode)\n   * - Builds a local HTTP-like request to the current Party room endpoint\n   *\n   * @param map - The map payload to apply on the server\n   *\n   * @example\n   * ```ts\n   * await updateMapService.update({ width: 1024, height: 768, events: [] })\n   * ```\n   */\n  async update(map: any) {\n    this.server = this.context.get('server')\n    const roomId = this.server?.room?.id ?? 'lobby-1'\n    const req = {\n      url: `http://localhost/parties/main/${roomId}/map/update`,\n      method: 'POST',\n      headers: new Headers({}),\n      json: async () => {\n        return map;\n      }\n    };\n    await this.server.onRequest(req)\n  }\n}\n\nexport function provideRpg(server: any, options: StandaloneOptions = {}) {\n  return [\n    {\n      provide: WebSocketToken,\n      useFactory: (context: Context) => new BridgeWebsocket(context, server, options),\n    },\n    {\n      provide: UpdateMapToken,\n      useClass: UpdateMapStandaloneService,\n    },\n    provideKeyboardControls(),\n    provideSaveClient(),\n    RpgGui,\n    RpgClientEngine,\n  ];\n}\n"],"mappings":"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"}

package/dist/utils/getEntityProp.d.ts

@@ -0,0 +1,39 @@
+import { Signal } from 'canvasengine';
+import { RpgClientObject } from '../Game/Object';
+declare const BUILTIN_PARAM_KEYS: readonly ["maxHp", "maxSp", "atk", "pdef", "sdef", "str", "agi", "int", "dex"];
+type BuiltInParamKey = typeof BUILTIN_PARAM_KEYS[number];
+type ParamPropKey = `params.${BuiltInParamKey}` | `params.${string}`;
+declare const entityPropMap: {
+    readonly level: (entity: RpgClientObject) => number;
+    readonly exp: (entity: RpgClientObject) => number;
+    readonly gold: (entity: RpgClientObject) => number;
+    readonly hp: (entity: RpgClientObject) => number;
+    readonly sp: (entity: RpgClientObject) => number;
+    readonly name: (entity: RpgClientObject) => string;
+    readonly type: (entity: RpgClientObject) => string;
+    readonly x: (entity: RpgClientObject) => number;
+    readonly y: (entity: RpgClientObject) => number;
+    readonly z: (entity: RpgClientObject) => number;
+    readonly tint: (entity: RpgClientObject) => string;
+    readonly direction: (entity: RpgClientObject) => import('@rpgjs/common').Direction;
+    readonly speed: (entity: RpgClientObject) => number;
+    readonly hitbox: (entity: RpgClientObject) => import('@rpgjs/common').Hitbox;
+    readonly animation: (entity: RpgClientObject) => string;
+    readonly canMove: (entity: RpgClientObject) => boolean;
+    readonly graphics: (entity: RpgClientObject) => any;
+    readonly items: (entity: RpgClientObject) => import('@rpgjs/common').Item[];
+    readonly equipments: (entity: RpgClientObject) => any[];
+    readonly states: (entity: RpgClientObject) => any[];
+    readonly skills: (entity: RpgClientObject) => import('@rpgjs/common').Skill[];
+    readonly effects: (entity: RpgClientObject) => any[];
+    readonly componentsTop: (entity: RpgClientObject) => string | null;
+    readonly componentsBottom: (entity: RpgClientObject) => string | null;
+    readonly componentsCenter: (entity: RpgClientObject) => string | null;
+    readonly componentsLeft: (entity: RpgClientObject) => string | null;
+    readonly componentsRight: (entity: RpgClientObject) => string | null;
+};
+type EntityPropMap = typeof entityPropMap;
+type EntityPropKey = keyof EntityPropMap | ParamPropKey;
+type EntityPropValue<K extends EntityPropKey> = K extends keyof EntityPropMap ? ReturnType<EntityPropMap[K]> : K extends `params.${string}` ? number | undefined : never;
+export declare const getEntityProp: <K extends EntityPropKey>(entity: Signal<RpgClientObject | undefined> | RpgClientObject | undefined, key: K) => Signal<EntityPropValue<K>>;
+export {};

package/dist/utils/getEntityProp.js

@@ -0,0 +1,52 @@
+import { computed } from "canvasengine";
+//#region src/utils/getEntityProp.ts
+var entityPropMap = {
+	level: (entity) => entity._level(),
+	exp: (entity) => entity._exp(),
+	gold: (entity) => entity._gold(),
+	hp: (entity) => entity.hpSignal(),
+	sp: (entity) => entity.spSignal(),
+	name: (entity) => entity.name(),
+	type: (entity) => entity.type(),
+	x: (entity) => entity.x(),
+	y: (entity) => entity.y(),
+	z: (entity) => entity.z(),
+	tint: (entity) => entity.tint(),
+	direction: (entity) => entity.direction(),
+	speed: (entity) => entity.speed(),
+	hitbox: (entity) => entity.hitbox(),
+	animation: (entity) => entity.animationName(),
+	canMove: (entity) => entity.canMove(),
+	graphics: (entity) => entity.graphics(),
+	items: (entity) => entity.items(),
+	equipments: (entity) => entity.equipments(),
+	states: (entity) => entity.states(),
+	skills: (entity) => entity.skills(),
+	effects: (entity) => entity._effects(),
+	componentsTop: (entity) => entity.componentsTop(),
+	componentsBottom: (entity) => entity.componentsBottom(),
+	componentsCenter: (entity) => entity.componentsCenter(),
+	componentsLeft: (entity) => entity.componentsLeft(),
+	componentsRight: (entity) => entity.componentsRight()
+};
+var isSignal = (value) => typeof value === "function";
+var toSignal = (value) => isSignal(value) ? value : computed(() => value);
+var getEntityProp = (entity, key) => {
+	const entitySignal = toSignal(entity);
+	return computed(() => {
+		const current = entitySignal();
+		if (!current) return;
+		if (Object.prototype.hasOwnProperty.call(entityPropMap, key)) {
+			const getter = entityPropMap[key];
+			return getter(current);
+		}
+		if (key.startsWith("params.")) {
+			const paramKey = key.slice(7);
+			return current._param?.()?.[paramKey];
+		}
+	});
+};
+//#endregion
+export { getEntityProp };
+
+//# sourceMappingURL=getEntityProp.js.map

package/dist/utils/getEntityProp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEntityProp.js","names":[],"sources":["../../src/utils/getEntityProp.ts"],"sourcesContent":["import { computed, Signal } from \"canvasengine\";\nimport { RpgClientObject } from \"../Game/Object\";\n\nconst BUILTIN_PARAM_KEYS = [\n  \"maxHp\",\n  \"maxSp\",\n  \"atk\",\n  \"pdef\",\n  \"sdef\",\n  \"str\",\n  \"agi\",\n  \"int\",\n  \"dex\",\n] as const;\n\ntype BuiltInParamKey = typeof BUILTIN_PARAM_KEYS[number];\ntype ParamPropKey = `params.${BuiltInParamKey}` | `params.${string}`;\n\nconst entityPropMap = {\n  level: (entity: RpgClientObject) => entity._level(),\n  exp: (entity: RpgClientObject) => entity._exp(),\n  gold: (entity: RpgClientObject) => entity._gold(),\n  hp: (entity: RpgClientObject) => entity.hpSignal(),\n  sp: (entity: RpgClientObject) => entity.spSignal(),\n  name: (entity: RpgClientObject) => entity.name(),\n  type: (entity: RpgClientObject) => entity.type(),\n  x: (entity: RpgClientObject) => entity.x(),\n  y: (entity: RpgClientObject) => entity.y(),\n  z: (entity: RpgClientObject) => entity.z(),\n  tint: (entity: RpgClientObject) => entity.tint(),\n  direction: (entity: RpgClientObject) => entity.direction(),\n  speed: (entity: RpgClientObject) => entity.speed(),\n  hitbox: (entity: RpgClientObject) => entity.hitbox(),\n  animation: (entity: RpgClientObject) => entity.animationName(),\n  canMove: (entity: RpgClientObject) => entity.canMove(),\n  graphics: (entity: RpgClientObject) => entity.graphics(),\n  items: (entity: RpgClientObject) => entity.items(),\n  equipments: (entity: RpgClientObject) => entity.equipments(),\n  states: (entity: RpgClientObject) => entity.states(),\n  skills: (entity: RpgClientObject) => entity.skills(),\n  effects: (entity: RpgClientObject) => entity._effects(),\n  componentsTop: (entity: RpgClientObject) => entity.componentsTop(),\n  componentsBottom: (entity: RpgClientObject) => entity.componentsBottom(),\n  componentsCenter: (entity: RpgClientObject) => entity.componentsCenter(),\n  componentsLeft: (entity: RpgClientObject) => entity.componentsLeft(),\n  componentsRight: (entity: RpgClientObject) => entity.componentsRight(),\n} as const;\n\ntype EntityPropMap = typeof entityPropMap;\ntype EntityPropKey = keyof EntityPropMap | ParamPropKey;\ntype EntityPropValue<K extends EntityPropKey> = K extends keyof EntityPropMap\n  ? ReturnType<EntityPropMap[K]>\n  : K extends `params.${string}`\n  ? number | undefined\n  : never;\n\nconst isSignal = <T>(value: unknown): value is Signal<T> =>\n  typeof value === \"function\";\n\nconst toSignal = <T>(value: Signal<T> | T): Signal<T> =>\n  isSignal<T>(value) ? value : computed(() => value);\n\nexport const getEntityProp = <K extends EntityPropKey>(\n  entity: Signal<RpgClientObject | undefined> | RpgClientObject | undefined,\n  key: K\n): Signal<EntityPropValue<K>> => {\n  const entitySignal = toSignal(entity);\n\n  return computed(() => {\n    const current = entitySignal();\n    if (!current) {\n      return undefined as EntityPropValue<K>;\n    }\n\n    if (Object.prototype.hasOwnProperty.call(entityPropMap, key)) {\n      const getter = entityPropMap[key as keyof EntityPropMap];\n      return getter(current) as EntityPropValue<K>;\n    }\n\n    if (key.startsWith(\"params.\")) {\n      const paramKey = key.slice(\"params.\".length);\n      return current._param?.()?.[paramKey] as EntityPropValue<K>;\n    }\n\n    return undefined as EntityPropValue<K>;\n  });\n};\n"],"mappings":";;AAkBA,IAAM,gBAAgB;CACpB,QAAQ,WAA4B,OAAO,QAAQ;CACnD,MAAM,WAA4B,OAAO,MAAM;CAC/C,OAAO,WAA4B,OAAO,OAAO;CACjD,KAAK,WAA4B,OAAO,UAAU;CAClD,KAAK,WAA4B,OAAO,UAAU;CAClD,OAAO,WAA4B,OAAO,MAAM;CAChD,OAAO,WAA4B,OAAO,MAAM;CAChD,IAAI,WAA4B,OAAO,GAAG;CAC1C,IAAI,WAA4B,OAAO,GAAG;CAC1C,IAAI,WAA4B,OAAO,GAAG;CAC1C,OAAO,WAA4B,OAAO,MAAM;CAChD,YAAY,WAA4B,OAAO,WAAW;CAC1D,QAAQ,WAA4B,OAAO,OAAO;CAClD,SAAS,WAA4B,OAAO,QAAQ;CACpD,YAAY,WAA4B,OAAO,eAAe;CAC9D,UAAU,WAA4B,OAAO,SAAS;CACtD,WAAW,WAA4B,OAAO,UAAU;CACxD,QAAQ,WAA4B,OAAO,OAAO;CAClD,aAAa,WAA4B,OAAO,YAAY;CAC5D,SAAS,WAA4B,OAAO,QAAQ;CACpD,SAAS,WAA4B,OAAO,QAAQ;CACpD,UAAU,WAA4B,OAAO,UAAU;CACvD,gBAAgB,WAA4B,OAAO,eAAe;CAClE,mBAAmB,WAA4B,OAAO,kBAAkB;CACxE,mBAAmB,WAA4B,OAAO,kBAAkB;CACxE,iBAAiB,WAA4B,OAAO,gBAAgB;CACpE,kBAAkB,WAA4B,OAAO,iBAAiB;CACvE;AAUD,IAAM,YAAe,UACnB,OAAO,UAAU;AAEnB,IAAM,YAAe,UACnB,SAAY,MAAM,GAAG,QAAQ,eAAe,MAAM;AAEpD,IAAa,iBACX,QACA,QAC+B;CAC/B,MAAM,eAAe,SAAS,OAAO;AAErC,QAAO,eAAe;EACpB,MAAM,UAAU,cAAc;AAC9B,MAAI,CAAC,QACH;AAGF,MAAI,OAAO,UAAU,eAAe,KAAK,eAAe,IAAI,EAAE;GAC5D,MAAM,SAAS,cAAc;AAC7B,UAAO,OAAO,QAAQ;;AAGxB,MAAI,IAAI,WAAW,UAAU,EAAE;GAC7B,MAAM,WAAW,IAAI,MAAM,EAAiB;AAC5C,UAAO,QAAQ,UAAU,GAAG;;GAI9B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/client",
-  "version": "5.0.0-alpha.8",
+  "version": "5.0.0-beta.1",
   "description": "RPGJS is a framework for creating RPG/MMORPG games",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
@@ -22,17 +22,21 @@
     "pixi.js": "^8.9.2"
   },
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.8",
-    "@signe/di": "^2.3.3",
-    "@signe/room": "^2.3.3",
-    "@signe/sync": "^2.3.3",
+    "@rpgjs/client": "5.0.0-beta.1",
+    "@rpgjs/common": "5.0.0-beta.1",
+    "@rpgjs/server": "5.0.0-beta.1",
+    "@rpgjs/ui-css": "5.0.0-beta.1",
+    "@signe/di": "^2.9.0",
+    "@signe/room": "^2.9.0",
+    "@signe/sync": "^2.9.0",
+    "pixi-filters": "^6.1.5",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@canvasengine/compiler": "2.0.0-beta.22",
-    "vite": "^6.2.5",
-    "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3.1.1"
+    "@canvasengine/compiler": "2.0.0-beta.56",
+    "vite": "^8.0.3",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.2"
   },
   "type": "module",
   "scripts": {

package/src/Game/{EffectManager.ts → AnimationManager.ts}

@@ -1,16 +1,17 @@
 import { generateUID, RpgCommonPlayer } from "@rpgjs/common";
 import { signal } from "canvasengine";
 
-export class EffectManager {
+export class AnimationManager {
   current = signal<any[]>([]);
 
-  displayEffect(params: any, player: RpgCommonPlayer) {
+  displayEffect(params: any, player: RpgCommonPlayer | { x: number, y: number }) {
     const id = generateUID();
     this.current().push({
       ...params,
       id,
       x: player.x,
       y: player.y,
+      object: player,
       onFinish: () => {
         const index = this.current().findIndex((value) => value.id === id);
         this.current().splice(index, 1);

package/src/Game/Event.ts

@@ -1,5 +1,5 @@
 import { RpgClientObject } from "./Object"; 
 
 export class RpgClientEvent extends RpgClientObject {
-    type = 'event'
+    _type = 'event'
 }   

package/src/Game/Map.ts

@@ -1,10 +1,102 @@
-import { RpgCommonMap } from "@rpgjs/common";
+import {
+  RpgCommonMap,
+  type WeatherState,
+  type MapPhysicsInitContext,
+  type MapPhysicsEntityContext,
+} from "@rpgjs/common";
 import { sync, users } from "@signe/sync";
 import { RpgClientPlayer } from "./Player";
-import { Signal, signal } from "canvasengine";
+import { Signal, signal, computed, effect } from "canvasengine";
 import { RpgClientEvent } from "./Event";
+import { RpgClientEngine } from "../RpgClientEngine";
+import { inject } from "../core/inject";
 
-export class RpgClientMap extends RpgCommonMap<RpgClientPlayer> {
+export class RpgClientMap extends RpgCommonMap<any> {
+  engine: RpgClientEngine = inject(RpgClientEngine)
   @users(RpgClientPlayer) players = signal<Record<string, RpgClientPlayer>>({});
   @sync(RpgClientEvent) events = signal<Record<string, RpgClientEvent>>({});
+  currentPlayer = computed(() => this.players()[this.engine.playerIdSignal()!])
+  weatherState = signal<WeatherState | null>(null);
+  localWeatherOverride = signal<WeatherState | null>(null);
+  weather = computed<WeatherState | null>(() => {
+    const local = this.localWeatherOverride() 
+    const state = this.weatherState()
+    return local ?? state
+  });
+  private manualClientPhysicsTick = false;
+  private readonly isTestEnvironment: boolean;
+
+  constructor() {
+    super();
+    // Détecter l'environnement de test
+    const isTest = (typeof process !== 'undefined' && process.env?.TEST === 'true')
+      || (typeof window !== 'undefined' && (window as any).__RPGJS_TEST__ === true);
+    this.isTestEnvironment = isTest;
+    if (isTest) {
+      this.autoTickEnabled = false;
+    }
+  }
+
+  configureClientPrediction(enabled: boolean): void {
+    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]
+      : undefined;
+
+    this.players.set(
+      currentPlayerId && currentPlayer ? { [currentPlayerId]: currentPlayer } : {}
+    );
+    this.events.set({})
+    this.weatherState.set(null);
+    this.localWeatherOverride.set(null);
+    this.clearPhysic()
+  }
+
+  getWeather(): WeatherState | null {
+    return this.weather();
+  }
+
+  setLocalWeather(next: WeatherState | null): void {
+    this.localWeatherOverride.set(next);
+  }
+
+  clearLocalWeather(): void {
+    this.localWeatherOverride.set(null);
+  }
+
+  stepClientPhysics(deltaMs: number): number {
+    if (!this.manualClientPhysicsTick) {
+      return 0;
+    }
+    return this.nextTick(deltaMs);
+  }
+
+  stepPredictionTick(): void {
+    this.forceSingleTick();
+  }
+
+  protected emitPhysicsInit(context: MapPhysicsInitContext): void {
+    this.engine?.emitSceneMapHook?.("onPhysicsInit", this, context);
+  }
+
+  protected emitPhysicsEntityAdd(context: MapPhysicsEntityContext): void {
+    this.engine?.emitSceneMapHook?.("onPhysicsEntityAdd", this, context);
+  }
+
+  protected emitPhysicsEntityRemove(context: MapPhysicsEntityContext): void {
+    this.engine?.emitSceneMapHook?.("onPhysicsEntityRemove", this, context);
+  }
+
+  protected emitPhysicsReset(): void {
+    this.engine?.emitSceneMapHook?.("onPhysicsReset", this);
+  }
 }