@rpgjs/server 5.0.0-alpha.24 → 5.0.0-alpha.26

package/dist/rooms/BaseRoom.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Base class for rooms that need database functionality
+ *
+ * This class provides common database management functionality that is shared
+ * between RpgMap and LobbyRoom. It includes methods for adding and managing
+ * items, classes, and other game data in the room's database.
+ *
+ * ## Architecture
+ *
+ * Both RpgMap and LobbyRoom need to store game entities (items, classes, skills, etc.)
+ * in a database. This base class provides the common implementation to avoid code duplication.
+ *
+ * @example
+ * ```ts
+ * class MyCustomRoom extends BaseRoom {
+ *   // Your custom room implementation
+ * }
+ * ```
+ */
+export declare abstract class BaseRoom {
+    /**
+     * Signal containing the room's database of items, classes, and other game data
+     *
+     * This database can be dynamically populated using `addInDatabase()` and
+     * `removeInDatabase()` methods. It's used to store game entities like items,
+     * classes, skills, etc. that are available in this room.
+     *
+     * @example
+     * ```ts
+     * // Add data to database
+     * room.addInDatabase('Potion', PotionClass);
+     *
+     * // Access database
+     * const potion = room.database()['Potion'];
+     * ```
+     */
+    database: import('@signe/reactive').WritableObjectSignal<{}>;
+    /**
+     * Add data to the room's database
+     *
+     * Adds an item, class, or other game entity to the room's database.
+     * If the ID already exists and `force` is not enabled, the addition is ignored.
+     *
+     * ## Architecture
+     *
+     * This method is used by the item management system to store item definitions
+     * in the room's database. When a player adds an item, the system first checks
+     * if the item exists in the database, and if not, adds it using this method.
+     *
+     * @param id - Unique identifier for the data
+     * @param data - The data to add (can be a class, object, etc.)
+     * @param options - Optional configuration
+     * @param options.force - If true, overwrites existing data with the same ID
+     * @returns `true` if data was added, `false` if it was ignored (ID already exists)
+     *
+     * @example
+     * ```ts
+     * // Add a class to the database
+     * room.addInDatabase('Potion', PotionClass);
+     *
+     * // Add an item object to the database
+     * room.addInDatabase('custom-item', {
+     *   name: 'Custom Item',
+     *   price: 100
+     * });
+     *
+     * // Force overwrite existing data
+     * room.addInDatabase('Potion', UpdatedPotionClass, { force: true });
+     * ```
+     */
+    addInDatabase(id: string, data: any, options?: {
+        force?: boolean;
+    }): boolean;
+    /**
+     * Remove data from the room's database
+     *
+     * This method allows you to remove items or data from the room's database.
+     *
+     * @param id - Unique identifier of the data to remove
+     * @returns `true` if data was removed, `false` if ID didn't exist
+     *
+     * @example
+     * ```ts
+     * // Remove an item from the database
+     * room.removeInDatabase('Potion');
+     *
+     * // Check if removal was successful
+     * const removed = room.removeInDatabase('custom-item');
+     * if (removed) {
+     *   console.log('Item removed successfully');
+     * }
+     * ```
+     */
+    removeInDatabase(id: string): boolean;
+}

package/dist/rooms/lobby.d.ts

@@ -1,6 +1,9 @@
 import { MockConnection } from '@signe/room';
 import { RpgPlayer } from '../Player/Player';
-export declare class LobbyRoom {
+import { BaseRoom } from './BaseRoom';
+export declare class LobbyRoom extends BaseRoom {
     players: import('@signe/reactive').WritableObjectSignal<{}>;
+    autoSync: boolean;
+    constructor(room: any);
     onJoin(player: RpgPlayer, conn: MockConnection): void;
 }

package/dist/rooms/map.d.ts

@@ -1,5 +1,5 @@
-import { MockConnection, RoomOnJoin } from '@signe/room';
-import { Hooks, RpgCommonMap, RpgShape, WorldMapsManager, WorldMapConfig } from '@rpgjs/common';
+import { MockConnection, RoomMethods, RoomOnJoin } from '@signe/room';
+import { Hooks, RpgCommonMap, RpgShape, WorldMapsManager, WorldMapConfig } from '../../../common/src';
 import { RpgPlayer, RpgEvent } from '../Player/Player';
 import { BehaviorSubject } from 'rxjs';
 import { MapOptions } from '../decorators/map';
@@ -162,7 +162,12 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     private _shapes;
     /** Internal: Map of shape entity UUIDs to RpgShape instances */
     private _shapeEntities;
-    constructor();
+    /** Internal: Subscription for the input processing loop */
+    private _inputLoopSubscription?;
+    /** Enable/disable automatic tick processing (useful for unit tests) */
+    private _autoTickEnabled;
+    autoSync: boolean;
+    constructor(room: any);
     /**
      * Setup collision detection between players, events, and shapes
      *
@@ -296,72 +301,6 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
      * ```
      */
     get hooks(): Hooks;
-    /**
-     * Get the width of the map in pixels
-     *
-     * @returns The width of the map in pixels, or 0 if not loaded
-     *
-     * @example
-     * ```ts
-     * const width = map.widthPx;
-     * console.log(`Map width: ${width}px`);
-     * ```
-     */
-    get widthPx(): number;
-    /**
-     * Get the height of the map in pixels
-     *
-     * @returns The height of the map in pixels, or 0 if not loaded
-     *
-     * @example
-     * ```ts
-     * const height = map.heightPx;
-     * console.log(`Map height: ${height}px`);
-     * ```
-     */
-    get heightPx(): number;
-    /**
-     * Get the unique identifier of the map
-     *
-     * @returns The map ID, or empty string if not loaded
-     *
-     * @example
-     * ```ts
-     * const mapId = map.id;
-     * console.log(`Current map: ${mapId}`);
-     * ```
-     */
-    get id(): string;
-    /**
-     * Get the X position of this map in the world coordinate system
-     *
-     * This is used when maps are part of a larger world map. The world position
-     * indicates where this map is located relative to other maps.
-     *
-     * @returns The X position in world coordinates, or 0 if not in a world
-     *
-     * @example
-     * ```ts
-     * const worldX = map.worldX;
-     * console.log(`Map is at world position (${worldX}, ${map.worldY})`);
-     * ```
-     */
-    get worldX(): number;
-    /**
-     * Get the Y position of this map in the world coordinate system
-     *
-     * This is used when maps are part of a larger world map. The world position
-     * indicates where this map is located relative to other maps.
-     *
-     * @returns The Y position in world coordinates, or 0 if not in a world
-     *
-     * @example
-     * ```ts
-     * const worldY = map.worldY;
-     * console.log(`Map is at world position (${map.worldX}, ${worldY})`);
-     * ```
-     */
-    get worldY(): number;
     /**
      * Handle GUI interaction from a player
      *
@@ -543,24 +482,43 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     /**
      * Main game loop that processes player inputs
      *
-     * This private method runs continuously every 50ms to process pending inputs
-     * for all players on the map. It ensures inputs are processed in order and
-     * prevents concurrent processing for the same player.
+     * This private method subscribes to tick$ and processes pending inputs
+     * for all players on the map with a throttle of 50ms. It ensures inputs are
+     * processed in order and prevents concurrent processing for the same player.
      *
      * ## Architecture
      *
-     * - Runs every 50ms for responsive input processing
+     * - Subscribes to tick$ with throttleTime(50ms) for responsive input processing
      * - Processes inputs for each player with pending inputs
      * - Uses a flag to prevent concurrent processing for the same player
      * - Calls `processInput()` to handle anti-cheat validation and movement
      *
      * @example
      * ```ts
-     * // This method is called automatically in the constructor
+     * // This method is called automatically in the constructor if autoTick is enabled
      * // You typically don't call it directly
      * ```
      */
     private loop;
+    /**
+     * Enable or disable automatic tick processing
+     *
+     * When disabled, the input processing loop will not run automatically.
+     * This is useful for unit tests where you want manual control over when
+     * inputs are processed.
+     *
+     * @param enabled - Whether to enable automatic tick processing (default: true)
+     *
+     * @example
+     * ```ts
+     * // Disable auto tick for testing
+     * map.setAutoTick(false);
+     *
+     * // Manually trigger tick processing
+     * await map.processInput('player1');
+     * ```
+     */
+    setAutoTick(enabled: boolean): void;
     /**
      * Get a world manager by id
      *
@@ -647,8 +605,7 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     /**
      * Add data to the map's database
      *
-     * This method allows you to dynamically add items, classes, or any data to the map's database.
-     * By default, if an ID already exists, the operation is ignored to prevent overwriting existing data.
+     * This method delegates to BaseRoom's implementation to avoid code duplication.
      *
      * @param id - Unique identifier for the data
      * @param data - The data to store (can be a class, object, or any value)
@@ -677,7 +634,7 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     /**
      * Remove data from the map's database
      *
-     * This method allows you to remove items or data from the map's database.
+     * This method delegates to BaseRoom's implementation to avoid code duplication.
      *
      * @param id - Unique identifier of the data to remove
      * @returns true if data was removed, false if ID didn't exist
@@ -986,6 +943,17 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
      * ```
      */
     setSync(schema: Record<string, any>): void;
+    /**
+     * Apply sync to the client
+     *
+     * This method applies sync to the client by calling the `$applySync()` method.
+     *
+     * @example
+     * ```ts
+     * map.applySyncToClient();
+     * ```
+     */
+    applySyncToClient(): void;
     /**
      * Create a shape dynamically on the map
      *
@@ -1244,9 +1212,27 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
         frequency?: number;
         direction?: 'x' | 'y' | 'both';
     }): void;
+    /**
+     * Clear all server resources and reset state
+     *
+     * This method should be called to clean up all server-side resources when
+     * shutting down or resetting the map. It stops the input processing loop
+     * and ensures that all subscriptions are properly cleaned up.
+     *
+     * ## Design
+     *
+     * This method is used primarily in testing environments to ensure clean
+     * state between tests. It stops the tick subscription to prevent memory leaks.
+     *
+     * @example
+     * ```ts
+     * // In test cleanup
+     * afterEach(() => {
+     *   map.clear();
+     * });
+     * ```
+     */
+    clear(): void;
 }
-export interface RpgMap {
-    $send: (conn: MockConnection, data: any) => void;
-    $broadcast: (data: any) => void;
-    $sessionTransfer: (userOrPublicId: any | string, targetRoomId: string) => void;
+export interface RpgMap extends RoomMethods {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.24",
+  "version": "5.0.0-alpha.26",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,13 +11,14 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.24",
-    "@rpgjs/physic": "5.0.0-alpha.24",
+    "@rpgjs/common": "5.0.0-alpha.26",
+    "@rpgjs/physic": "5.0.0-alpha.26",
+    "@rpgjs/testing": "5.0.0-alpha.26",
     "@rpgjs/database": "^4.3.0",
-    "@signe/di": "^2.6.0",
-    "@signe/reactive": "^2.6.0",
-    "@signe/room": "^2.6.0",
-    "@signe/sync": "^2.6.0",
+    "@signe/di": "^2.7.2",
+    "@signe/reactive": "^2.7.2",
+    "@signe/room": "^2.7.2",
+    "@signe/sync": "^2.7.2",
     "rxjs": "^7.8.2",
     "zod": "^4.1.13"
   },
@@ -28,6 +29,7 @@
   "type": "module",
   "scripts": {
     "dev": "vite build --watch",
-    "build": "vite build"
+    "build": "vite build",
+    "test": "vitest"
   }
 }

package/src/Player/ItemManager.ts

@@ -206,8 +206,10 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       });
     }
     addItem(item: ItemClass | ItemObject | string, nb: number = 1): Item {
-      const map = (this as any).getCurrentMap();
-      if (!map) {
+      // Use this.map directly to support both RpgMap and LobbyRoom
+      // If no map, player is in Lobby
+      const map = (this as any).getCurrentMap() || (this as any).map;
+      if (!map || !map.database) {
         throw new Error('Player must be on a map to add items');
       }
 
@@ -219,11 +221,6 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       if (isString(item)) {
         itemId = item as string;
         data = (this as any).databaseById(itemId);
-        if (!data) {
-          throw new Error(
-            `The ID=${itemId} data is not found in the database. Add the data in the property "database"`
-          );
-        }
       }
       // Handle class: create instance and add to database if needed
       else if (typeof item === 'function' || (item as any).prototype) {
@@ -271,13 +268,34 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       let instance: Item;
 
       if (existingItem) {
-        // Item already exists, just update quantity
+        // Item already exists, update quantity and merge properties
         instance = existingItem;
         instance.quantity.update((it) => it + nb);
+        
+        // Update item properties from merged data (e.g., name, description, price)
+        if (data.name !== undefined) {
+          instance.name.set(data.name);
+        }
+        if (data.description !== undefined) {
+          instance.description.set(data.description);
+        }
+        if (data.price !== undefined) {
+          instance.price.set(data.price);
+        }
+        
+        // Update stored instance if it's an object with hooks
+        if (itemInstance && typeof itemInstance === 'object' && !(itemInstance instanceof Function)) {
+          (instance as any)._itemInstance = itemInstance;
+          // Update hooks if they exist
+          if (itemInstance.onAdd) {
+            instance.onAdd = itemInstance.onAdd.bind(itemInstance);
+          }
+        }
       } else {
         // Create new item instance
         instance = new Item(data);
         instance.id.set(itemId);
+        instance.quantity.set(nb);
 
         // Attach hooks from class instance or object
         if (itemInstance) {
@@ -294,6 +312,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
 
       // Call onAdd hook - use stored instance if available
       const hookTarget = (instance as any)._itemInstance || instance;
+      // Only call onAdd if it exists and is a function
       (this as any)["execMethod"]("onAdd", [this], hookTarget);
       return instance;
     }
@@ -315,7 +334,9 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       }
       // Call onRemove hook - use stored instance if available
       const hookTarget = (item as any)._itemInstance || item;
-      this["execMethod"]("onRemove", [this], hookTarget);
+      if (hookTarget && typeof hookTarget.onRemove === 'function') {
+        this["execMethod"]("onRemove", [this], hookTarget);
+      }
       return this.items()[itemIndex];
     }
 
@@ -373,7 +394,13 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
     getParamItem(name: string): number {
       let nb = 0;
       for (let item of this.equipments()) {
-        nb += item[name] || 0;
+        // Retrieve item data from database to get properties like atk, pdef, sdef
+        try {
+          const itemData = (this as any).databaseById(item.id());
+          nb += itemData[name] || 0;
+        } catch {
+          // If item not in database, skip it
+        }
       }
       const modifier = (this as any).paramsModifier?.[name];
       if (modifier) {
@@ -404,19 +431,31 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
       }
-      const item = inventory;
-      if ((item as any).consumable === false) {
+      
+      // Retrieve item data from database to check consumable and hitRate
+      const itemData = (this as any).databaseById(itemId);
+      const consumable = itemData?.consumable;
+      
+      // If consumable is explicitly false, throw error
+      if (consumable === false) {
         throw ItemLog.notUseItem(itemId);
       }
-      const hitRate = (item as any).hitRate ?? 1;
-      const hookTarget = (item as any)._itemInstance || item;
+      
+      // If consumable is undefined and item is not of type 'item', it's not consumable
+      if (consumable === undefined && itemData?._type && itemData._type !== 'item') {
+        throw ItemLog.notUseItem(itemId);
+      }
+      
+      const hitRate = itemData?.hitRate ?? 1;
+      const hookTarget = (inventory as any)._itemInstance || inventory;
+      
       if (Math.random() > hitRate) {
         this.removeItem(itemClass);
         this["execMethod"]("onUseFailed", [this], hookTarget);
         throw ItemLog.chanceToUseFailed(itemId);
       }
-      (this as any).applyEffect?.(item);
-      (this as any).applyStates?.(this, item);
+      (this as any).applyEffect?.(itemData);
+      (this as any).applyStates?.(this, itemData);
       this["execMethod"]("onUse", [this], hookTarget);
       this.removeItem(itemClass);
       return inventory;

package/src/Player/ParameterManager.ts

@@ -580,6 +580,9 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
         this.hpSignal.set(val)
     }
 
+    get hp(): number {
+        return this.hpSignal()
+    }
 
     /** 
      * Changes the skill points
@@ -601,7 +604,9 @@ export function WithParameterManager<TBase extends PlayerCtor>(Base: TBase) {
         this.spSignal.set(val)
     }
 
-   
+    get sp(): number {
+        return this.spSignal()
+    }   
 
     /** 
      * Changing the player's experience.