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

package/dist/Player/MoveManager.d.ts

@@ -3,6 +3,51 @@ import { RpgPlayer } from './Player';
 type CallbackTileMove = (player: RpgPlayer, map: any) => Direction[];
 type CallbackTurnMove = (player: RpgPlayer, map: any) => string;
 type Routes = (string | Promise<any> | Direction | Direction[] | Function)[];
+/**
+ * Options for moveRoutes method
+ */
+export interface MoveRoutesOptions {
+    /**
+     * Callback function called when the player gets stuck (cannot move towards target)
+     *
+     * This callback is triggered when the player is trying to move but cannot make progress
+     * towards the target position, typically due to obstacles or collisions.
+     *
+     * @param player - The player instance that is stuck
+     * @param target - The target position the player was trying to reach
+     * @param currentPosition - The current position of the player
+     * @returns If true, the route will continue; if false, the route will be cancelled
+     *
+     * @example
+     * ```ts
+     * await player.moveRoutes([Move.right()], {
+     *   onStuck: (player, target, currentPos) => {
+     *     console.log('Player is stuck!');
+     *     return false; // Cancel the route
+     *   }
+     * });
+     * ```
+     */
+    onStuck?: (player: RpgPlayer, target: {
+        x: number;
+        y: number;
+    }, currentPosition: {
+        x: number;
+        y: number;
+    }) => boolean | void;
+    /**
+     * Time in milliseconds to wait before considering the player stuck (default: 500ms)
+     *
+     * The player must be unable to make progress for this duration before onStuck is called.
+     */
+    stuckTimeout?: number;
+    /**
+     * Minimum distance change in pixels to consider movement progress (default: 1 pixel)
+     *
+     * If the player moves less than this distance over the stuckTimeout period, they are considered stuck.
+     */
+    stuckThreshold?: number;
+}
 export declare enum Frequency {
     Lowest = 600,
     Lower = 400,
@@ -49,6 +94,21 @@ export declare enum Speed {
 * @memberof Move
 * */
 declare class MoveList {
+    private static perlinNoise;
+    private static randomCounter;
+    private static callCounter;
+    /**
+     * Gets a random direction index (0-3) using a hybrid approach for balanced randomness
+     *
+     * Uses a combination of hash-based pseudo-randomness and Perlin noise to ensure
+     * fair distribution of directions while maintaining smooth, natural-looking movement patterns.
+     * The hash function guarantees uniform distribution, while Perlin noise adds spatial/temporal coherence.
+     *
+     * @param player - Optional player instance for coordinate-based noise
+     * @param index - Optional index for array-based calls to ensure variation
+     * @returns Direction index (0-3) corresponding to Right, Left, Up, Down
+     */
+    private getRandomDirectionIndex;
     repeatMove(direction: Direction, repeat: number): Direction[];
     private repeatTileMove;
     right(repeat?: number): Direction[];
@@ -283,9 +343,10 @@ export interface IMoveManager {
      * Give an itinerary to follow using movement strategies
      *
      * @param routes - Array of movement instructions to execute
+     * @param options - Optional configuration including onStuck callback
      * @returns Promise that resolves when all routes are completed
      */
-    moveRoutes(routes: Routes): Promise<boolean>;
+    moveRoutes(routes: Routes, options?: MoveRoutesOptions): Promise<boolean>;
     /**
      * Give a path that repeats itself in a loop to a character
      *

package/dist/Player/Player.d.ts

@@ -1,4 +1,5 @@
 import { Hooks, RpgCommonPlayer, Constructor, Direction, AttachShapeOptions, RpgShape } from '../../../common/src';
+import { Vector2 } from '../../../physic/src';
 import { IComponentManager } from './ComponentManager';
 import { RpgMap } from '../rooms/map';
 import { Context } from '@signe/di';
@@ -40,6 +41,34 @@ export declare class RpgPlayer extends RpgPlayer_base {
     context?: Context;
     conn: MockConnection | null;
     touchSide: boolean;
+    /**
+     * Computed signal for world X position
+     *
+     * Calculates the absolute world X position from the map's world position
+     * plus the player's local X position. Returns 0 if no map is assigned.
+     *
+     * @example
+     * ```ts
+     * const worldX = player.worldX();
+     * console.log(`Player is at world X: ${worldX}`);
+     * ```
+     */
+    get worldPositionX(): any;
+    /**
+     * Computed signal for world Y position
+     *
+     * Calculates the absolute world Y position from the map's world position
+     * plus the player's local Y position. Returns 0 if no map is assigned.
+     *
+     * @example
+     * ```ts
+     * const worldY = player.worldY();
+     * console.log(`Player is at world Y: ${worldY}`);
+     * ```
+     */
+    get worldPositionY(): any;
+    private _worldPositionSignals;
+    private _getComputedWorldPosition;
     /** Internal: Shapes attached to this player */
     private _attachedShapes;
     /** Internal: Shapes where this player is currently located */
@@ -66,6 +95,7 @@ export declare class RpgPlayer extends RpgPlayer_base {
     _onInit(): void;
     get hooks(): Hooks;
     get server(): RpgMap | null;
+    setMap(map: RpgMap): void;
     applyFrames(): void;
     execMethod(method: string, methodData?: any[], target?: any): Promise<any>;
     /**
@@ -89,28 +119,7 @@ export declare class RpgPlayer extends RpgPlayer_base {
         y: number;
         z?: number;
     } | string): Promise<any | null | boolean>;
-    /**
-     * Auto change map when player touches map borders
-     *
-     * This method checks if the player touches the current map borders
-     * and automatically performs a change to the adjacent map if it exists.
-     *
-     * @param nextPosition - The next position of the player
-     * @returns Promise<boolean> - true if a map change occurred
-     *
-     * @example
-     * ```ts
-     * // Called automatically by the movement system
-     * const changed = await player.autoChangeMap({ x: newX, y: newY });
-     * if (changed) {
-     *   console.log('Player changed map automatically');
-     * }
-     * ```
-     */
-    autoChangeMap(nextPosition: {
-        x: number;
-        y: number;
-    }, forcedDirection?: any): Promise<boolean>;
+    autoChangeMap(nextPosition: Vector2): Promise<boolean>;
     teleport(positions: {
         x: number;
         y: number;
@@ -450,10 +459,12 @@ export declare class RpgPlayer extends RpgPlayer_base {
      * @param schema - The schema to set
      */
     setSync(schema: any): void;
+    isEvent(): boolean;
 }
 export declare class RpgEvent extends RpgPlayer {
     execMethod(methodName: string, methodData?: any[], instance?: this): Promise<any>;
     remove(): void;
+    isEvent(): boolean;
 }
 /**
  * Interface extension for RpgPlayer

package/dist/index.d.ts

@@ -13,3 +13,4 @@ export * from './Gui';
 export { RpgShape, RpgModule } from '../../common/src';
 export * from './decorators/event';
 export * from './decorators/map';
+export * from './Player/MoveManager';