@rpgjs/server 4.2.2 → 5.0.0-alpha.0

package/{lib → dist}/Gui/DialogGui.d.ts

@@ -1,6 +1,5 @@
 import { Gui } from './Gui';
 import { RpgPlayer } from '../Player/Player';
-import { IGui } from '../Interfaces/Gui';
 export declare enum DialogPosition {
     Top = "top",
     Bottom = "bottom",
@@ -19,7 +18,7 @@ export interface DialogOptions {
     typewriterEffect?: boolean;
     talkWith?: RpgPlayer;
 }
-export declare class DialogGui extends Gui implements IGui {
+export declare class DialogGui extends Gui {
     constructor(player: RpgPlayer);
     openDialog(message: string, options: DialogOptions): Promise<any>;
 }

package/{lib → dist}/Gui/Gui.d.ts

@@ -1,6 +1,5 @@
 import { RpgPlayer } from '../Player/Player';
-import { EventEmitter } from '@rpgjs/common';
-export declare class Gui extends EventEmitter {
+export declare class Gui {
     id: string;
     protected player: RpgPlayer;
     private _close;

package/dist/Player/BattleManager.d.ts

@@ -0,0 +1,22 @@
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { RpgPlayer } from './Player';
+interface PlayerWithMixins extends RpgCommonPlayer {
+    parameters: any[];
+    getFormulas(name: string): any;
+    hasEffect(effect: string): boolean;
+    coefficientElements(attackerPlayer: RpgPlayer): number;
+    hp: number;
+    getFormulas(name: string): any;
+    hasEffect(effect: string): boolean;
+}
+export interface IBattleManager {
+    applyDamage(attackerPlayer: RpgPlayer, skill?: any): {
+        damage: number;
+        critical: boolean;
+        elementVulnerable: boolean;
+        guard: boolean;
+        superGuard: boolean;
+    };
+}
+export declare function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(Base: TBase): Constructor<IBattleManager> & TBase;
+export {};

package/dist/Player/ClassManager.d.ts

@@ -0,0 +1,18 @@
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+type ClassClass = any;
+type ActorClass = any;
+interface PlayerWithMixins extends RpgCommonPlayer {
+    databaseById(id: string): any;
+    addParameter(name: string, { start, end }: {
+        start: number;
+        end: number;
+    }): void;
+    addItem(item: any): void;
+    equip(item: any, equip: boolean): void;
+}
+export interface IClassManager {
+    setClass(_class: ClassClass | string): ClassClass;
+    setActor(actorClass: ActorClass | string): ActorClass;
+}
+export declare function WithClassManager<TBase extends Constructor<PlayerWithMixins>>(Base: TBase): Constructor<IClassManager> & TBase;
+export {};

package/dist/Player/ItemManager.d.ts

@@ -0,0 +1,17 @@
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { ItemClass } from '@rpgjs/database';
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IItemManager {
+    databaseById(id: string): ItemClass;
+}
+/**
+ * Move Manager mixin
+ *
+ * Adds methods to manage player movement
+ *
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
+ */
+export declare function WithItemManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): Constructor<IItemManager> & TBase;

package/dist/Player/MoveManager.d.ts

@@ -0,0 +1,177 @@
+import { Constructor, RpgCommonPlayer, Direction, MovementStrategy, ProjectileType } from '@rpgjs/common';
+import { RpgPlayer } from './Player';
+export interface IMoveManager {
+    addMovement(strategy: MovementStrategy): void;
+    removeMovement(strategy: MovementStrategy): boolean;
+    clearMovements(): void;
+    hasActiveMovements(): boolean;
+    getActiveMovements(): MovementStrategy[];
+    moveTo(target: RpgCommonPlayer | {
+        x: number;
+        y: number;
+    }): void;
+    stopMoveTo(): void;
+    dash(direction: {
+        x: number;
+        y: number;
+    }, speed?: number, duration?: number): void;
+    knockback(direction: {
+        x: number;
+        y: number;
+    }, force?: number, duration?: number): void;
+    followPath(waypoints: Array<{
+        x: number;
+        y: number;
+    }>, speed?: number, loop?: boolean): void;
+    oscillate(direction: {
+        x: number;
+        y: number;
+    }, amplitude?: number, period?: number): void;
+    applyIceMovement(direction: {
+        x: number;
+        y: number;
+    }, maxSpeed?: number): void;
+    shootProjectile(type: ProjectileType, direction: {
+        x: number;
+        y: number;
+    }, speed?: number): void;
+    moveRoutes(routes: Routes): Promise<boolean>;
+    infiniteMoveRoute(routes: Routes): void;
+    breakRoutes(force?: boolean): void;
+    replayRoutes(): void;
+}
+type CallbackTileMove = (player: RpgPlayer, map: any) => Direction[];
+type CallbackTurnMove = (player: RpgPlayer, map: any) => string;
+type Routes = (string | Promise<any> | Direction | Direction[] | Function)[];
+export declare enum Frequency {
+    Lowest = 600,
+    Lower = 400,
+    Low = 200,
+    High = 100,
+    Higher = 50,
+    Highest = 25,
+    None = 0
+}
+export declare enum Speed {
+    Slowest = 0.2,
+    Slower = 0.5,
+    Slow = 1,
+    Normal = 3,
+    Fast = 5,
+    Faster = 7,
+    Fastest = 10
+}
+/**
+* @title Move
+* @enum {Object}
+*
+* Move.right(repeat=1) | Movement of a number of pixels on the right
+* Move.left(repeat=1) | Movement of a number of pixels on the left
+* Move.up(repeat=1) | Movement of a number of pixels on the up
+* Move.down(repeat=1) | Movement of a number of pixels on the down
+* Move.random(repeat=1) | Movement of a number of pixels in a random direction
+* Move.towardPlayer(player, repeat=1) | Moves a number of pixels in the direction of the designated player
+* Move.awayFromPlayer(player, repeat=1) | Moves a number of pixels in the opposite direction of the designated player
+* Move.tileRight(repeat=1) | Movement of a number of tiles on the right
+* Move.tileLeft(repeat=1) | Movement of a number of tiles on the left
+* Move.tileUp(repeat=1) | Movement of a number of tiles on the up
+* Move.tileDown(repeat=1) | Movement of a number of tiles on the down
+* Move.tileRandom(repeat=1) | Movement of a number of tiles in a random direction
+* Move.tileTowardPlayer(player, repeat=1) | Moves a number of tiles in the direction of the designated player
+* Move.tileAwayFromPlayer(player, repeat=1) | Moves a number of tiles in the opposite direction of the designated player
+* Move.turnRight() | Turn to the right
+* Move.turnLeft() | Turn to the left
+* Move.turnUp() | Turn to the up
+* Move.turnDown() | Turn to the down
+* Move.turnRandom() | Turn to random direction
+* Move.turnAwayFromPlayer(player) | Turns in the opposite direction of the designated player
+* Move.turnTowardPlayer(player) | Turns in the direction of the designated player
+* @memberof Move
+* */
+declare class MoveList {
+    repeatMove(direction: Direction, repeat: number): Direction[];
+    private repeatTileMove;
+    right(repeat?: number): Direction[];
+    left(repeat?: number): Direction[];
+    up(repeat?: number): Direction[];
+    down(repeat?: number): Direction[];
+    wait(sec: number): Promise<unknown>;
+    random(repeat?: number): Direction[];
+    tileRight(repeat?: number): CallbackTileMove;
+    tileLeft(repeat?: number): CallbackTileMove;
+    tileUp(repeat?: number): CallbackTileMove;
+    tileDown(repeat?: number): CallbackTileMove;
+    tileRandom(repeat?: number): CallbackTileMove;
+    private _awayFromPlayerDirection;
+    private _towardPlayerDirection;
+    private _awayFromPlayer;
+    towardPlayer(player: RpgPlayer, repeat?: number): (player: RpgPlayer, map: any) => any;
+    tileTowardPlayer(player: RpgPlayer, repeat?: number): (player: RpgPlayer, map: any) => any;
+    awayFromPlayer(player: RpgPlayer, repeat?: number): CallbackTileMove;
+    tileAwayFromPlayer(player: RpgPlayer, repeat?: number): CallbackTileMove;
+    turnLeft(): string;
+    turnRight(): string;
+    turnUp(): string;
+    turnDown(): string;
+    turnRandom(): string;
+    turnAwayFromPlayer(otherPlayer: RpgPlayer): CallbackTurnMove;
+    turnTowardPlayer(otherPlayer: RpgPlayer): CallbackTurnMove;
+}
+export declare const Move: MoveList;
+/**
+ * Move Manager mixin
+ *
+ * Adds comprehensive movement management capabilities to a player class.
+ * Provides access to all available movement strategies and utility methods
+ * for common movement patterns.
+ *
+ * ## Features
+ * - **Strategy Management**: Add, remove, and query movement strategies
+ * - **Predefined Movements**: Quick access to common movement patterns
+ * - **Composite Movements**: Combine multiple strategies
+ * - **Physics Integration**: Seamless integration with Matter.js physics
+ *
+ * ## Available Movement Strategies
+ * - `LinearMove`: Constant velocity movement
+ * - `Dash`: Quick burst movement
+ * - `Knockback`: Push effect with decay
+ * - `PathFollow`: Follow waypoint sequences
+ * - `Oscillate`: Back-and-forth patterns
+ * - `SeekAvoid`: AI pathfinding with obstacle avoidance
+ * - `LinearRepulsion`: Smoother obstacle avoidance
+ * - `IceMovement`: Slippery surface physics
+ * - `ProjectileMovement`: Ballistic trajectories
+ * - `CompositeMovement`: Combine multiple strategies
+ *
+ * @param Base - The base class to extend
+ * @returns A new class with comprehensive movement management capabilities
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * class MyPlayer extends WithMoveManager(RpgCommonPlayer) {
+ *   onInput(direction: { x: number, y: number }) {
+ *     // Apply dash movement on input
+ *     this.dash(direction, 8, 200);
+ *   }
+ *
+ *   onIceTerrain() {
+ *     // Switch to ice physics
+ *     this.clearMovements();
+ *     this.applyIceMovement({ x: 1, y: 0 }, 4);
+ *   }
+ *
+ *   createPatrol() {
+ *     // Create patrol path
+ *     const waypoints = [
+ *       { x: 100, y: 100 },
+ *       { x: 300, y: 100 },
+ *       { x: 300, y: 300 }
+ *     ];
+ *     this.followPath(waypoints, 2, true);
+ *   }
+ * }
+ * ```
+ */
+export declare function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): Constructor<IMoveManager> & TBase;
+export {};

package/dist/Player/ParameterManager.d.ts

@@ -0,0 +1,42 @@
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+export interface IWithParameterManager {
+    parameters: Map<string, any>;
+    hp: number;
+    sp: number;
+    exp: number;
+    level: number;
+    expForNextlevel: number;
+    param: {
+        [key: string]: number;
+    };
+    paramsModifier: {
+        [key: string]: {
+            value?: number;
+            rate?: number;
+        };
+    };
+}
+/**
+ * Mixin that adds parameter management functionality to a player class.
+ *
+ * This mixin provides comprehensive parameter management including:
+ * - Health Points (HP) and Skill Points (SP) management
+ * - Experience and level progression system
+ * - Custom parameter creation and modification
+ * - Parameter modifiers for temporary stat changes
+ *
+ * @template TBase - The base class constructor type
+ * @param Base - The base class to extend
+ * @returns A new class that extends the base with parameter management capabilities
+ *
+ * @example
+ * ```ts
+ * class MyPlayer extends WithParameterManager(BasePlayer) {
+ *   constructor() {
+ *     super();
+ *     this.addParameter('strength', { start: 10, end: 100 });
+ *   }
+ * }
+ * ```
+ */
+export declare function WithParameterManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase): TBase & Constructor<IWithParameterManager>;

package/dist/Player/Player.d.ts

@@ -0,0 +1,73 @@
+import { RpgCommonPlayer, ShowAnimationParams, Constructor, ZoneOptions } from '@rpgjs/common';
+import { IComponentManager } from './ComponentManager';
+import { RpgMap } from '../rooms/map';
+import { Context } from '@signe/di';
+import { IGuiManager } from './GuiManager';
+import { MockConnection } from '@signe/room';
+import { IMoveManager } from './MoveManager';
+import { IGoldManager } from './GoldManager';
+import { IWithVariableManager } from './VariableManager';
+import { IWithParameterManager } from './ParameterManager';
+import { IWithSkillManager } from './SkillManager';
+declare const RpgPlayer_base: Constructor<RpgCommonPlayer>;
+/**
+ * RPG Player class with component management capabilities
+ */
+export declare class RpgPlayer extends RpgPlayer_base {
+    map: RpgMap | null;
+    context?: Context;
+    conn: MockConnection | null;
+    events: import('@signe/reactive').WritableArraySignal<RpgEvent[]>;
+    constructor();
+    execMethod(method: string, methodData?: any[], target?: any): Promise<any>;
+    /**
+     * Change the map for this player
+     *
+     * @param mapId - The ID of the map to change to
+     * @param positions - Optional positions to place the player at
+     * @returns A promise that resolves when the map change is complete
+     *
+     * @example
+     * ```ts
+     * // Change player to map "town" at position {x: 10, y: 20}
+     * await player.changeMap("town", {x: 10, y: 20});
+     *
+     * // Change player to map "dungeon" at a named position
+     * await player.changeMap("dungeon", "entrance");
+     * ```
+     */
+    changeMap(mapId: string, positions?: {
+        x: number;
+        y: number;
+        z?: number;
+    } | string): Promise<any | null | boolean>;
+    teleport(positions: {
+        x: number;
+        y: number;
+    }): Promise<false | undefined>;
+    getCurrentMap<T extends RpgMap = RpgMap>(): T | null;
+    emit(type: string, value?: any): void;
+    showAnimation(params: ShowAnimationParams): void;
+    /**
+     * Run the change detection cycle. Normally, as soon as a hook is called in a class, the cycle is started. But you can start it manually
+     * The method calls the `onChanges` method on events and synchronizes all map data with the client.
+  
+    * @title Run Sync Changes
+    * @method player.syncChanges()
+    * @returns {void}
+    * @memberof Player
+    */
+    syncChanges(): void;
+    databaseById(id: string): any;
+    private _eventChanges;
+    attachShape(id: string, options: ZoneOptions): void;
+    broadcastEffect(id: string, params: any): void;
+    showHit(text: string): void;
+}
+export declare class RpgEvent extends RpgPlayer {
+    execMethod(methodName: string, methodData?: any[], instance?: this): Promise<any>;
+    remove(): void;
+}
+export interface RpgPlayer extends RpgCommonPlayer, IComponentManager, IGuiManager, IMoveManager, IGoldManager, IWithVariableManager, IWithParameterManager, IWithSkillManager {
+}
+export {};

package/dist/Player/SkillManager.d.ts

@@ -0,0 +1,23 @@
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { RpgPlayer } from './Player';
+/**
+ * Interface defining dependencies from other mixins that SkillManager needs
+ */
+interface SkillManagerDependencies {
+    sp: number;
+    skills(): any[];
+    hasEffect(effect: string): boolean;
+    databaseById(id: string): any;
+    applyStates(player: RpgPlayer, skill: any): void;
+}
+/**
+ * Interface defining what SkillManager adds to a class
+ */
+export interface IWithSkillManager {
+    getSkill(skillClass: any | string): any;
+    learnSkill(skillId: any | string): any;
+    forgetSkill(skillId: any | string): any;
+    useSkill(skillId: any | string, otherPlayer?: RpgPlayer | RpgPlayer[]): any;
+}
+export declare function WithSkillManager<TBase extends Constructor<RpgCommonPlayer & SkillManagerDependencies>>(Base: TBase): Constructor<IWithSkillManager> & TBase;
+export {};

package/dist/Player/StateManager.d.ts

@@ -0,0 +1,39 @@
+import { Constructor, RpgCommonPlayer } from '@rpgjs/common';
+import { WritableArraySignal } from '@signe/reactive';
+import { RpgPlayer } from './Player';
+interface StateManagerDependencies {
+    equipments(): any[];
+    databaseById(id: string | StateClass): any;
+    addState(stateClass: StateClass | string, chance?: number): object | null;
+    removeState(stateClass: StateClass | string, chance?: number): void;
+}
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IStateManager {
+    statesDefense: {
+        rate: number;
+        state: any;
+    }[];
+    statesEfficiency: WritableArraySignal<any[]>;
+    applyStates(player: RpgPlayer, states: {
+        addStates?: any[];
+        removeStates?: any[];
+    }): void;
+    getState(stateClass: StateClass | string): any;
+    addState(stateClass: StateClass | string, chance?: number): object | null;
+    removeState(stateClass: StateClass | string, chance?: number): void;
+}
+type StateClass = {
+    new (...args: any[]): any;
+};
+/**
+ * Move Manager mixin
+ *
+ * Adds methods to manage player movement
+ *
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
+ */
+export declare function WithStateManager<TBase extends Constructor<RpgCommonPlayer & StateManagerDependencies>>(Base: TBase): Constructor<IStateManager> & TBase;
+export {};

package/{lib → dist}/RpgServer.d.ts

@@ -1,13 +1,16 @@
-import { ModuleType, RpgShape, Direction, Control } from '@rpgjs/common';
-import { RpgClassEvent, RpgEvent, RpgPlayer } from './Player/Player';
-import { RpgMap } from './Game/Map';
-import { RpgServerEngine } from './server';
-import { MapOptions } from './decorators/map';
-import { RpgClassMap } from './Scenes/Map';
-import { TiledMap } from '@rpgjs/tiled';
-import { WorldMap } from './Game/WorldMaps';
-import { MatchMakerOption, RpgMatchMaker } from './MatchMaker';
-import { IStoreState } from './Interfaces/StateStore';
+import { RpgPlayer } from './Player/Player';
+import { RpgMap } from './rooms/map';
+import { RpgServerEngine } from './RpgServerEngine';
+type RpgShape = any;
+type RpgClassMap<T> = any;
+type RpgClassEvent<T> = any;
+type RpgEvent = any;
+type MatchMakerOption = any;
+type RpgMatchMaker = any;
+type IStoreState = any;
+type TiledMap = any;
+type WorldMap = any;
+type MapOptions = any;
 export interface RpgServerEngineHooks {
     /**
      *  When the server starts
@@ -36,7 +39,7 @@ export interface RpgServerEngineHooks {
       *
       * @param {RpgServerEngine} server - The instance of the game server.
       * @param {SocketIO.Socket} socket - The socket instance for the connecting player. This can be used to access client-sent data, like tokens or other credentials.
-      * @returns {Promise<string> | string} The function should return a promise that resolves to a player's unique identifier (e.g., user ID) if authentication is successful, or a string representing the user's ID. Alternatively, it can throw an error if authentication fails.
+      * @returns {Promise<string> | string  | undefined} The function should return a promise that resolves to a player's unique identifier (e.g., user ID) if authentication is successful, or a string representing the user's ID. Alternatively, it can throw an error if authentication fails. If undefined is returned, the player id is generated.
       * @throws {string} Throwing an error will prevent the player from connecting, signifying a failed authentication attempt.
       *
       * @example
@@ -51,7 +54,7 @@ export interface RpgServerEngineHooks {
       * };
       * ```
       */
-    auth?: (server: RpgServerEngine, socket: any) => Promise<string> | string | never;
+    auth?: (server: RpgServerEngine, socket: any) => Promise<string> | string | never | undefined;
 }
 export interface RpgPlayerHooks {
     /**
@@ -145,10 +148,7 @@ export interface RpgPlayerHooks {
     * @prop { (player: RpgPlayer, data: { input: Direction | Control | string, moving: boolean }) => any } [onInput]
     * @memberof RpgPlayerHooks
     */
-    onInput?: (player: RpgPlayer, data: {
-        input: Direction | Control | string;
-        moving: boolean;
-    }) => any;
+    onInput?: (player: RpgPlayer, data: any) => any;
     /**
     *  When the player leaves the map
     *
@@ -210,6 +210,20 @@ export interface RpgPlayerHooks {
     */
     canChangeMap?: (player: RpgPlayer, nextMap: RpgClassMap<RpgMap>) => boolean | Promise<boolean>;
 }
+export interface RpgEventHooks {
+    onInit?: (event: RpgEvent) => any;
+    onAction?: (event: RpgEvent, player: RpgPlayer) => any;
+    onBeforeCreated?: (object: any, map: RpgMap) => any;
+    onDetectInShape?: (event: RpgEvent, player: RpgPlayer, shape: RpgShape) => any;
+    onDetectOutShape?: (event: RpgEvent, player: RpgPlayer, shape: RpgShape) => any;
+    onInShape?: (event: RpgEvent, shape: RpgShape) => any;
+    onOutShape?: (event: RpgEvent, shape: RpgShape) => any;
+    onPlayerTouch?: (event: RpgEvent, player: RpgPlayer) => any;
+    onChanges?: (event: RpgEvent, player: RpgPlayer) => any;
+}
+export interface RpgMapHooks {
+    onBeforeUpdate<T = RpgMap>(mapData: any, map: T): T;
+}
 export interface RpgServer {
     /**
      * Add hooks to the player or engine. All modules can listen to the hook
@@ -262,7 +276,7 @@ export interface RpgServer {
      * @prop { { client: null | Function, server: null | Function }[]} [imports]
      * @memberof RpgServer
      */
-    imports?: ModuleType[];
+    imports?: any;
     /**
      * Object containing the hooks concerning the engine
      *
@@ -377,6 +391,8 @@ export interface RpgServer {
      * @memberof RpgServer
      * */
     maps?: RpgClassMap<RpgMap>[] | MapOptions[] | string[] | TiledMap[];
+    map?: RpgMapHooks;
+    event?: RpgEventHooks;
     /**
      * Array of all events. Each element is an `RpgEvent` class
      * Events can be used by placing a shape with the name of the event on Tiled Map Editor
@@ -477,3 +493,4 @@ export interface RpgServer {
         };
     };
 }
+export {};

package/dist/RpgServerEngine.d.ts

@@ -0,0 +1,5 @@
+import { Server } from '@signe/room';
+import { LobbyRoom } from './rooms/lobby';
+export declare class RpgServerEngine extends Server {
+    rooms: (typeof LobbyRoom)[];
+}

package/dist/core/context.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@signe/di';
+export declare const context: Context<any, any, Record<string, any>>;

package/dist/core/inject.d.ts

@@ -0,0 +1,5 @@
+import { Context } from '@signe/di';
+export declare let context: Context | null;
+export declare function inject<T>(service: (new (...args: any[]) => T) | string, _context?: Context): T;
+export declare function setInject(_context: Context): void;
+export declare function clearInject(): void;

package/dist/core/setup.d.ts

@@ -0,0 +1,6 @@
+import { Providers } from '@signe/di';
+interface SetupOptions {
+    providers: Providers;
+}
+export declare function createServer(options: SetupOptions): any;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './RpgServerEngine';
+export * from './Player/MoveManager';
+export * from './RpgServer';
+export * from './core/setup';
+export * from './core/inject';
+export * from './Player/Player';
+export * from './module';
+export * from './rooms/map';
+export * from './presets';