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

package/src/rooms/map.ts

@@ -1,18 +1,19 @@
-import { Action, MockConnection, Request, Room, RoomOnJoin } from "@signe/room";
-import { Hooks, IceMovement, ModulesToken, ProjectileMovement, ProjectileType, RpgCommonMap, Direction, RpgCommonPlayer, RpgShape } from "@rpgjs/common";
+import { Action, MockConnection, Request, Room, RoomMethods, RoomOnJoin } from "@signe/room";
+import { Hooks, IceMovement, ModulesToken, ProjectileMovement, ProjectileType, RpgCommonMap, Direction, RpgCommonPlayer, RpgShape, findModules } from "@rpgjs/common";
 import { WorldMapsManager, type WorldMapConfig } from "@rpgjs/common";
 import { RpgPlayer, RpgEvent } from "../Player/Player";
 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";
 import { z } from "zod";
 import { EntityState } from "@rpgjs/physic";
 import { MapOptions } from "../decorators/map";
+import { BaseRoom } from "./BaseRoom";
 
 /**
  * Interface for input controls configuration
@@ -113,7 +114,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   @users(RpgPlayer) players = signal({});
-  
+
   /** 
    * Synchronized signal containing all events (NPCs, objects) on the map
    * 
@@ -130,7 +131,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   @sync(RpgPlayer) events = signal({});
-  
+
   /** 
    * Signal containing the map's database of items, classes, and other game data
    * 
@@ -148,7 +149,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   database = signal({});
-  
+
   /** 
    * Array of map configurations - can contain MapOptions objects or instances of map classes
    * 
@@ -156,7 +157,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * It's populated when the map is loaded via `updateMap()`.
    */
   maps: (MapOptions | any)[] = []
-  
+
   /** 
    * Array of sound IDs to play when players join the map
    * 
@@ -170,7 +171,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   sounds: string[] = []
-  
+
   /** 
    * BehaviorSubject that completes when the map data is ready
    * 
@@ -186,7 +187,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   dataIsReady$ = new BehaviorSubject<void>(undefined);
-  
+
   /** 
    * Global configuration object for the map
    * 
@@ -194,7 +195,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * It's populated from the map data when `updateMap()` is called.
    */
   globalConfig: any = {}
-  
+
   /** 
    * Damage formulas configuration for the map
    * 
@@ -207,15 +208,32 @@ 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;
+
+  autoSync: boolean = true;
 
-  constructor() {
+  constructor(room) {
     super();
     this.hooks.callHooks("server-map-onStart", this).subscribe();
-    this.throttleSync = this.isStandalone ? 0 : 50; // Reduced from 100ms to 50ms for better responsiveness
-    this.throttleStorage = this.isStandalone ? 0 : 1000;
-    this.sessionExpiryTime = 1000 * 60 * 5; //5 minutes
+    const isTest = room.env.TEST === 'true' ? true : false;
+    if (isTest) {
+      this.autoSync = false;
+      this.setAutoTick(false);
+      this.throttleSync = 0;
+      this.throttleStorage = 0;
+    }
+    else {
+      this.throttleSync = this.isStandalone ? 1 : 50
+      this.throttleStorage = this.isStandalone ? 1 : 50
+    };
+    this.sessionExpiryTime = 1000 * 60 * 5;
     this.setupCollisionDetection();
-    this.loop();
+    if (this._autoTickEnabled) {
+      this.loop();
+    }
   }
 
   /**
@@ -285,7 +303,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
         // One of the entities is a shape
         const shape = shapeA || shapeB;
         const otherEntity = shapeA ? entityB : entityA;
-        
+
         if (shape) {
           const shapeKey = `${otherEntity.uuid}-${shape.name}`;
           if (!activeShapeCollisions.has(shapeKey)) {
@@ -321,7 +339,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       if (event) {
         // Mark this collision as processed
         activeCollisions.add(collisionKey);
-        
+
         // Trigger the onPlayerTouch hook on the event
         event.execMethod('onPlayerTouch', [player]);
       }
@@ -344,7 +362,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
         // One of the entities is a shape
         const shape = shapeA || shapeB;
         const otherEntity = shapeA ? entityB : entityA;
-        
+
         if (shape) {
           const shapeKey = `${otherEntity.uuid}-${shape.name}`;
           if (activeShapeCollisions.has(shapeKey)) {
@@ -461,7 +479,11 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   onJoin(player: RpgPlayer, conn: MockConnection) {
-    player.map = this;
+    if (player.setMap) {
+      player.setMap(this);
+    } else {
+      player.map = this;
+    }
     player.context = context;
     player.conn = conn;
     player._onInit()
@@ -471,17 +493,17 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
         if ((this as any).stopAllSoundsBeforeJoin) {
           player.stopAllSounds();
         }
-        
-        this.sounds.forEach(sound => player.playSound(sound,{ loop: true }));
-        
+
+        this.sounds.forEach(sound => player.playSound(sound, { loop: true }));
+
         // Execute global map hooks (from RpgServer.map)
         await lastValueFrom(this.hooks.callHooks("server-map-onJoin", player, this));
-        
+
         // // Execute map-specific hooks (from @MapData or MapOptions)
         if (typeof (this as any)._onJoin === 'function') {
           await (this as any)._onJoin(player);
         }
-        
+
         // Execute player hooks
         await lastValueFrom(this.hooks.callHooks("server-player-onJoinMap", player, this));
       })
@@ -514,12 +536,12 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   async onLeave(player: RpgPlayer, conn: MockConnection) {
     // Execute global map hooks (from RpgServer.map)
     await lastValueFrom(this.hooks.callHooks("server-map-onLeave", player, this));
-    
+
     // Execute map-specific hooks (from @MapData or MapOptions)
     if (typeof (this as any)._onLeave === 'function') {
       await (this as any)._onLeave(player);
     }
-    
+
     // Execute player hooks
     await lastValueFrom(this.hooks.callHooks("server-player-onLeaveMap", player, this));
     player.pendingInputs = [];
@@ -543,89 +565,6 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     return inject<Hooks>(context, ModulesToken);
   }
 
-  /**
-   * 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 {
-    return this.data()?.width ?? 0
-  }
-
-  /**
-   * 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 {
-    return this.data()?.height ?? 0
-  }
-
-  /**
-   * 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 {
-    return this.data()?.id ?? ''
-  }
-
-  /**
-   * 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 {
-    const worldMaps = this.getWorldMapsManager?.();
-    return worldMaps?.getMapInfo(this.id)?.worldX ?? 0
-  }
-  
-  /**
-   * 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 {
-    const worldMaps = this.getWorldMapsManager?.();
-    return worldMaps?.getMapInfo(this.id)?.worldY ?? 0
-  }
-
   /**
    * Handle GUI interaction from a player
    * 
@@ -643,7 +582,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    */
   @Action('gui.interaction')
   guiInteraction(player: RpgPlayer, value) {
-    //this.hooks.callHooks("server-player-guiInteraction", player, value);
+    this.hooks.callHooks("server-player-guiInteraction", player, value);
     player.syncChanges();
   }
 
@@ -785,6 +724,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     }
     await lastValueFrom(this.hooks.callHooks("server-maps-load", this))
     await lastValueFrom(this.hooks.callHooks("server-worldMaps-load", this))
+    await lastValueFrom(this.hooks.callHooks("server-databaseHooks-load", this))
 
     map.events = map.events ?? []
 
@@ -805,7 +745,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       else {
         this.sounds = map.sounds ?? []
       }
-      
+
       // Attach map-specific hooks from MapOptions or @MapData
       if (mapFound?.onLoad) {
         (this as any)._onLoad = mapFound.onLoad;
@@ -830,15 +770,15 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     }
 
     this.dataIsReady$.complete()
-    
+
     // Execute global map hooks (from RpgServer.map)
     await lastValueFrom(this.hooks.callHooks("server-map-onLoad", this))
-    
+
     // Execute map-specific hooks (from @MapData or MapOptions)
     if (typeof (this as any)._onLoad === 'function') {
       await (this as any)._onLoad();
     }
-    
+
     // TODO: Update map
   }
 
@@ -1052,25 +992,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 +1028,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;
+    }
   }
 
   /**
@@ -1192,8 +1166,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   /**
    * 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)
@@ -1217,23 +1190,13 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   addInDatabase(id: string, data: any, options?: { force?: boolean }): boolean {
-    const database = this.database();
-    
-    // Check if ID already exists
-    if (database[id] !== undefined && !options?.force) {
-      // Ignore the addition if ID exists and force is not enabled
-      return false;
-    }
-    
-    // Add or overwrite the data
-    database[id] = data;
-    return true;
+    return BaseRoom.prototype.addInDatabase.call(this, id, data, options);
   }
 
   /**
    * 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
@@ -1251,16 +1214,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
    * ```
    */
   removeInDatabase(id: string): boolean {
-    const database = this.database();
-    
-    // Check if ID exists
-    if (database[id] === undefined) {
-      return false;
-    }
-    
-    // Remove the data
-    delete database[id];
-    return true;
+    return BaseRoom.prototype.removeInDatabase.call(this, id);
   }
 
   /**
@@ -1368,7 +1322,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 
     eventInstance.x.set(x);
     eventInstance.y.set(y);
-    
+
     this.events()[id] = eventInstance;
 
     await eventInstance.execMethod('onInit')
@@ -1668,6 +1622,20 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     }
   }
 
+  /**
+   * Apply sync to the client
+   * 
+   * This method applies sync to the client by calling the `$applySync()` method.
+   * 
+   * @example
+   * ```ts
+   * map.applySyncToClient();
+   * ```
+   */
+  applySyncToClient() {
+    this.$applySync();
+  }
+
   /**
    * Create a shape dynamically on the map
    * 
@@ -1744,7 +1712,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     properties?: Record<string, any>;
   }): RpgShape {
     const { x, y, width, height } = obj;
-    
+
     // Validate required parameters
     if (typeof x !== 'number' || typeof y !== 'number') {
       throw new Error('Shape x and y must be numbers');
@@ -2036,10 +2004,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 {
-  $send: (conn: MockConnection, data: any) => void;
-  $broadcast: (data: any) => void;
-  $sessionTransfer: (userOrPublicId: any | string, targetRoomId: string) => void;
-}
+export interface RpgMap extends RoomMethods { }

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)
+})