@rpgjs/server 5.0.0-alpha.23 → 5.0.0-alpha.25

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 { Hooks, RpgCommonMap, RpgShape, WorldMapsManager, WorldMapConfig } from '../../../common/src';
 import { RpgPlayer, RpgEvent } from '../Player/Player';
 import { BehaviorSubject } from 'rxjs';
 import { MapOptions } from '../decorators/map';
@@ -162,6 +162,10 @@ export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoi
     private _shapes;
     /** Internal: Map of shape entity UUIDs to RpgShape instances */
     private _shapeEntities;
+    /** Internal: Subscription for the input processing loop */
+    private _inputLoopSubscription?;
+    /** Enable/disable automatic tick processing (useful for unit tests) */
+    private _autoTickEnabled;
     constructor();
     /**
      * Setup collision detection between players, events, and shapes
@@ -543,24 +547,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
      *
@@ -1244,6 +1267,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/server",
-  "version": "5.0.0-alpha.23",
+  "version": "5.0.0-alpha.25",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "publishConfig": {
@@ -11,23 +11,25 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@rpgjs/common": "5.0.0-alpha.23",
-    "@rpgjs/physic": "5.0.0-alpha.23",
+    "@rpgjs/common": "5.0.0-alpha.25",
+    "@rpgjs/physic": "5.0.0-alpha.25",
+    "@rpgjs/testing": "5.0.0-alpha.25",
     "@rpgjs/database": "^4.3.0",
-    "@signe/di": "^2.5.2",
-    "@signe/reactive": "^2.5.2",
-    "@signe/room": "^2.5.2",
-    "@signe/sync": "^2.5.2",
+    "@signe/di": "^2.6.0",
+    "@signe/reactive": "^2.6.0",
+    "@signe/room": "^2.6.0",
+    "@signe/sync": "^2.6.0",
     "rxjs": "^7.8.2",
     "zod": "^4.1.13"
   },
   "devDependencies": {
-    "vite": "^7.2.6",
+    "vite": "^7.2.7",
     "vite-plugin-dts": "^4.5.4"
   },
   "type": "module",
   "scripts": {
     "dev": "vite build --watch",
-    "build": "vite build"
+    "build": "vite build",
+    "test": "vitest"
   }
 }

package/src/Player/ItemManager.ts

@@ -278,6 +278,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
         // 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 +295,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 +317,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];
     }
 

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. 

package/src/Player/Player.ts

@@ -185,7 +185,9 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   async execMethod(method: string, methodData: any[] = [], target?: any) {
     let ret: any;
     if (target) {
-      ret = await target[method](...methodData);
+      if (typeof target[method] === 'function') {
+        ret = await target[method](...methodData);
+      }
     }
     else {
       ret = await lastValueFrom(this.hooks
@@ -268,13 +270,13 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       const worldPositionX = (map.worldX ?? 0) + this.x();
       const worldPositionY = (map.worldY ?? 0) + this.y();
 
-      const changeMap = async (adjacentCoords: {x: number, y: number}, positionCalculator: (nextMapInfo: any) => {x: number, y: number}) => {
+      const changeMap = async (directionNumber: number, positionCalculator: (nextMapInfo: any) => {x: number, y: number}) => {
         if (this.touchSide) {
           return false;
         }
         this.touchSide = true;
 
-        const [nextMap] = worldMaps.getAdjacentMaps(map, adjacentCoords);
+        const [nextMap] = worldMaps.getAdjacentMaps(map, directionNumber);
         if (!nextMap) {
           this.touchSide = false;
           return false;
@@ -299,40 +301,28 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
       };
   // Check left border
       if (nextPosition.x < marginLeftRight && direction === Direction.Left) {
-        ret = await changeMap({
-          x: (map.worldX ?? 0) - 1,
-          y: worldPositionY
-        }, nextMapInfo => ({
+        ret = await changeMap(2, nextMapInfo => ({
           x: nextMapInfo.width - (this.hitbox().w) - marginLeftRight,
           y: (map.worldY ?? 0) - (nextMapInfo.y ?? 0) + nextPosition.y
         }));
       }
       // Check right border
       else if (nextPosition.x > map.widthPx - this.hitbox().w - marginLeftRight && direction === Direction.Right) {
-        ret = await changeMap({
-          x: (map.worldX ?? 0) + map.widthPx + 1,
-          y: worldPositionY
-        }, nextMapInfo => ({
+        ret = await changeMap(3, nextMapInfo => ({
           x: marginLeftRight,
           y: (map.worldY ?? 0) - (nextMapInfo.y ?? 0) + nextPosition.y
         }));
       }
       // Check top border
       else if (nextPosition.y < marginTopDown && direction === Direction.Up) {
-        ret = await changeMap({
-          x: worldPositionX,
-          y: (map.worldY ?? 0) - 1
-        }, nextMapInfo => ({
+        ret = await changeMap(0, nextMapInfo => ({
           x: (map.worldX ?? 0) - (nextMapInfo.x ?? 0) + nextPosition.x,
           y: nextMapInfo.height - this.hitbox().h - marginTopDown
         }));
       }
       // Check bottom border
       else if (nextPosition.y > map.heightPx - this.hitbox().h - marginTopDown && direction === Direction.Down) {
-        ret = await changeMap({
-          x: worldPositionX,
-          y: (map.worldY ?? 0) + map.heightPx + 1
-        }, nextMapInfo => ({
+        ret = await changeMap(1, nextMapInfo => ({
           x: (map.worldX ?? 0) - (nextMapInfo.x ?? 0) + nextPosition.x,
           y: marginTopDown
         }));

package/src/rooms/map.ts

@@ -6,7 +6,7 @@ import { generateShortUUID, sync, type, users } from "@signe/sync";
 import { signal } from "@signe/reactive";
 import { inject } from "@signe/di";
 import { context } from "../core/context";;
-import { finalize, lastValueFrom } from "rxjs";
+import { finalize, lastValueFrom, throttleTime } from "rxjs";
 import { Subject } from "rxjs";
 import { BehaviorSubject } from "rxjs";
 import { COEFFICIENT_ELEMENTS, DAMAGE_CRITICAL, DAMAGE_PHYSIC, DAMAGE_SKILL } from "../presets";
@@ -207,6 +207,10 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   private _shapes: Map<string, RpgShape> = new Map();
   /** Internal: Map of shape entity UUIDs to RpgShape instances */
   private _shapeEntities: Map<string, RpgShape> = new Map();
+  /** Internal: Subscription for the input processing loop */
+  private _inputLoopSubscription?: any;
+  /** Enable/disable automatic tick processing (useful for unit tests) */
+  private _autoTickEnabled: boolean = true;
 
   constructor() {
     super();
@@ -215,7 +219,9 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     this.throttleStorage = this.isStandalone ? 0 : 1000;
     this.sessionExpiryTime = 1000 * 60 * 5; //5 minutes
     this.setupCollisionDetection();
-    this.loop();
+    if (this._autoTickEnabled) {
+      this.loop();
+    }
   }
 
   /**
@@ -1052,25 +1058,31 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   /**
    * 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() {
-    setInterval(async () => {
+    if (this._inputLoopSubscription) {
+      this._inputLoopSubscription.unsubscribe();
+    }
+    
+    this._inputLoopSubscription = this.tick$.pipe(
+      throttleTime(50) // Throttle to 50ms for input processing
+    ).subscribe(async ({ timestamp }) => {
       for (const player of this.getPlayers()) {
         if (player.pendingInputs.length > 0) {
           const anyPlayer = player as any;
@@ -1082,7 +1094,35 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
           }
         }
       }
-    }, 50); // Increased frequency from 100ms to 50ms for better responsiveness
+    });
+  }
+
+  /**
+   * 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 {
+    this._autoTickEnabled = enabled;
+    if (enabled && !this._inputLoopSubscription) {
+      this.loop();
+    } else if (!enabled && this._inputLoopSubscription) {
+      this._inputLoopSubscription.unsubscribe();
+      this._inputLoopSubscription = undefined;
+    }
   }
 
   /**
@@ -2036,6 +2076,38 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       },
     });
   }
+
+  /**
+   * 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 {
+    try {
+      // Stop input processing loop
+      if (this._inputLoopSubscription) {
+        this._inputLoopSubscription.unsubscribe();
+        this._inputLoopSubscription = undefined;
+      }
+    } catch (error) {
+      console.warn('Error during map cleanup:', error);
+    }
+  }
 }
 
 export interface RpgMap {

package/tests/change-map.spec.ts

@@ -0,0 +1,72 @@
+import { beforeEach, test, expect, afterEach } from 'vitest'
+import { testing } from '@rpgjs/testing'
+import { defineModule, createModule } from '@rpgjs/common'
+import { RpgPlayer, RpgServer } from '../src'
+import { RpgClient } from '../../client/src'
+
+// Define server module with two maps
+const serverModule = defineModule<RpgServer>({
+  maps: [
+    {
+      id: 'map1',
+      file: '',
+    },
+    {
+      id: 'map2',
+      file: '',
+    }
+  ],
+  player: {
+    async onConnected(player) {
+      // Start player on map1
+      await player.changeMap('map1', { x: 100, y: 100 })
+    },
+    onJoinMap(player) {
+      console.log('onJoinMap', player.getCurrentMap()?.id)
+    }
+  }
+})
+
+// Define client module
+const clientModule = defineModule<RpgClient>({
+  // Client-side logic
+})
+
+let player: RpgPlayer
+let client: any
+let fixture: any
+
+beforeEach(async () => {
+    const myModule = createModule('TestModule', [{
+        server: serverModule,
+        client: clientModule
+    }])
+    
+    fixture = await testing(myModule)
+    client = await fixture.createClient()
+    player = client.player
+})
+
+afterEach(() => {
+  fixture.clear()
+})
+
+test('Player can change map', async () => {
+    player = await client.waitForMapChange('map1')
+    
+    const initialMap = player.getCurrentMap()
+    expect(initialMap).toBeDefined()
+    expect(initialMap?.id).toBe('map1')
+    
+    const result = await player.changeMap('map2', { x: 200, y: 200 })
+    expect(result).toBe(true)
+    
+    player = await client.waitForMapChange('map2')
+    
+    const newMap = player.getCurrentMap()
+    expect(newMap).toBeDefined()
+    expect(newMap?.id).toBe('map2')
+    
+    expect(player.x()).toBe(200 - player.hitbox().h / 2)
+    expect(player.y()).toBe(200 - player.hitbox().w / 2)
+})