@rpgjs/server 4.2.2 → 5.0.0-alpha.0

package/dist/module.d.ts

@@ -0,0 +1,2 @@
+import { FactoryProvider } from '@signe/di';
+export declare function provideServerModules(modules: any[]): FactoryProvider;

package/dist/rooms/lobby.d.ts

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

package/dist/rooms/map.d.ts

@@ -0,0 +1,110 @@
+import { MockConnection, RoomOnJoin } from '@signe/room';
+import { Hooks, RpgCommonMap, ZoneData } from '@rpgjs/common';
+import { RpgPlayer, RpgEvent } from '../Player/Player';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Interface representing hook methods available for map events
+ *
+ * These hooks are triggered at specific moments during the event lifecycle
+ */
+export interface EventHooks {
+    /** Called when the event is first initialized */
+    onInit?: () => void;
+    /** Called when the event properties change */
+    onChanges?: (player: RpgPlayer) => void;
+    /** Called when a player performs an action on this event */
+    onAction?: (player: RpgPlayer) => void;
+    /** Called when a player touches this event */
+    onPlayerTouch?: (player: RpgPlayer) => void;
+    /** Called when a player enters a shape */
+    onInShape?: (zone: ZoneData, player: RpgPlayer) => void;
+    /** Called when a player exits a shape */
+    onOutShape?: (zone: ZoneData, player: RpgPlayer) => void;
+    onDetectInShape?: (player: RpgPlayer, shape: ZoneData) => void;
+    onDetectOutShape?: (player: RpgPlayer, shape: ZoneData) => void;
+}
+/** Type for event class constructor */
+export type EventConstructor = new () => RpgPlayer;
+/** Options for positioning and defining an event on the map */
+export type EventPosOption = {
+    /** ID of the event */
+    id?: string;
+    /** X position of the event on the map */
+    x: number;
+    /** Y position of the event on the map */
+    y: number;
+    /**
+     * Event definition - can be either:
+     * - A class that extends RpgPlayer
+     * - An object with hook methods
+     */
+    event: EventConstructor | (EventHooks & Record<string, any>);
+};
+export declare class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
+    players: import('@signe/reactive').WritableObjectSignal<{}>;
+    events: import('@signe/reactive').WritableObjectSignal<{}>;
+    database: import('@signe/reactive').WritableObjectSignal<{}>;
+    maps: any[];
+    dataIsReady$: BehaviorSubject<void>;
+    globalConfig: any;
+    damageFormulas: any;
+    onJoin(player: RpgPlayer, conn: MockConnection): void;
+    get hooks(): Hooks;
+    guiInteraction(player: RpgPlayer, value: any): void;
+    guiExit(player: RpgPlayer, { guiId, data }: {
+        guiId: any;
+        data: any;
+    }): void;
+    onAction(player: RpgPlayer, action: any): void;
+    onInput(player: RpgPlayer, input: any): void;
+    updateMap(request: Request): Promise<void>;
+    addInDatabase(id: string, data: any): void;
+    /**
+     * Creates a dynamic event on the map
+     *
+     * This method handles both class-based events and object-based events with hooks.
+     * For class-based events, it creates a new instance of the class.
+     * For object-based events, it creates a dynamic class that extends RpgPlayer and
+     * implements the hook methods from the object.
+     *
+     * @param eventObj - The event position and definition
+     *
+     * @example
+     * // Using a class-based event
+     * class MyEvent extends RpgPlayer {
+     *   onInit() {
+     *     console.log('Event initialized');
+     *   }
+     * }
+     *
+     * map.createDynamicEvent({
+     *   x: 100,
+     *   y: 200,
+     *   event: MyEvent
+     * });
+     *
+     * // Using an object-based event
+     * map.createDynamicEvent({
+     *   x: 100,
+     *   y: 200,
+     *   event: {
+     *     onInit() {
+     *       console.log('Event initialized');
+     *     },
+     *     onPlayerTouch(player) {
+     *       console.log('Player touched event');
+     *     }
+     *   }
+     * });
+     */
+    createDynamicEvent(eventObj: EventPosOption): Promise<void>;
+    getEvent<T extends RpgPlayer>(eventId: string): T | undefined;
+    getPlayer(playerId: string): RpgPlayer | undefined;
+    getEvents(): RpgEvent[];
+    removeEvent(eventId: string): void;
+    showAnimation(animationName: string, object: RpgPlayer): void;
+}
+export interface RpgMap {
+    $send: (conn: MockConnection, data: any) => void;
+    $broadcast: (data: any) => void;
+}

package/package.json

@@ -1,53 +1,31 @@
 {
   "name": "@rpgjs/server",
-  "version": "4.2.2",
-  "description": "",
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "version": "5.0.0-alpha.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc && npm run build:browser",
-    "build:browser": "RPG_TYPE=rpg npx rpgjs build",
-    "watch": "tsc -w"
-  },
-  "typesVersions": {
-    "*": {
-      "express": [
-        "lib/express/server.d.ts"
-      ]
-    }
-  },
-  "exports": {
-    ".": "./lib/index.js",
-    "./express": "./lib/express/server.js"
+    "dev": "vite build --watch",
+    "build": "vite build"
   },
   "keywords": [],
-  "author": "Samuel Ronce",
+  "author": "",
   "license": "MIT",
+  "description": "",
   "dependencies": {
-    "@rpgjs/common": "^4.2.1",
-    "@rpgjs/database": "^4.2.1",
-    "@rpgjs/tiled": "^4.2.1",
-    "@rpgjs/types": "^4.0.5",
-    "axios": "^1.3.6",
-    "cors": "^2.8.5",
-    "express": "^4.18.2",
-    "lodash.merge": "^4.6.2",
-    "pretty-error": "^4.0.0",
-    "rxjs": "7.8.0",
-    "sat": "^0.9.0",
-    "simple-room": "^3.1.3",
-    "socket.io": "^4.6.1"
+    "@rpgjs/common": "workspace:*",
+    "@rpgjs/database": "^4.3.0",
+    "@signe/di": "^2.3.2",
+    "@signe/reactive": "^2.3.2",
+    "@signe/room": "^2.3.2",
+    "@signe/sync": "^2.3.2",
+    "rxjs": "^7.8.2"
   },
-  "gitHead": "35eb6d01ae6e13f195df46a92fe785eeaf806189",
   "devDependencies": {
-    "@rpgjs/compiler": "^4.2.1",
-    "typescript": "^5.0.4"
-  },
-  "alias": {
-    "express": "./lib/express/server"
+    "vite": "^6.2.5",
+    "vite-plugin-dts": "^4.5.3"
   },
   "type": "module"
 }

package/src/Gui/DialogGui.ts

@@ -1,7 +1,6 @@
 import { PrebuiltGui } from '@rpgjs/common'
 import { Gui } from './Gui'
 import { RpgPlayer } from '../Player/Player'
-import { IGui } from '../Interfaces/Gui'
 import { Move } from '../Player/MoveManager'
 
 export enum DialogPosition {
@@ -22,7 +21,7 @@ export interface DialogOptions {
     talkWith?: RpgPlayer
 }
 
-export class DialogGui extends Gui implements IGui {
+export class DialogGui extends Gui {
     constructor(player: RpgPlayer) {
         super(PrebuiltGui.Dialog, player)
     }
@@ -36,7 +35,7 @@ export class DialogGui extends Gui implements IGui {
         const event = options.talkWith
         let memoryDir
         if (event) {
-            memoryDir = event.direction
+            memoryDir = event.direction()
             event.breakRoutes(true)
             event.moveRoutes([ Move.turnTowardPlayer(this.player) ])
         }
@@ -59,7 +58,7 @@ export class DialogGui extends Gui implements IGui {
         }).then((val: any) => {
             if (event) {
                 event.replayRoutes()
-                event.direction = memoryDir
+                event.changeDirection(memoryDir)
             }
             return val
         })

package/src/Gui/Gui.ts

@@ -1,7 +1,6 @@
 import { RpgPlayer } from '../Player/Player'
-import { EventEmitter } from '@rpgjs/common'
 
-export class Gui extends EventEmitter {
+export class Gui {
 
     private _close: Function = () => {}
     private _blockPlayerInput: boolean = false
@@ -10,7 +9,7 @@ export class Gui extends EventEmitter {
         public id: string,
         protected player: RpgPlayer,
     ) {
-        super()
+        
     }
 
     open(data?, {
@@ -18,14 +17,13 @@ export class Gui extends EventEmitter {
         blockPlayerInput = false
     } = {}): Promise<any> {
         return new Promise((resolve) => {
-            this.player.moving = false
             this.player.emit('gui.open', {
                 guiId: this.id,
                 data
             })
             this._blockPlayerInput = blockPlayerInput
             if (blockPlayerInput) {
-                this.player.canMove = false
+               this.player.canMove.set(false)
             }
             if (!waitingAction) {
                 resolve(null)
@@ -39,7 +37,7 @@ export class Gui extends EventEmitter {
     close(data?) {
         this.player.emit('gui.exit', this.id)
         if (this._blockPlayerInput) {
-            this.player.canMove = true
+            this.player.canMove.set(true)
         }
         this._close(data)
     }

package/src/Player/BattleManager.ts

@@ -1,124 +1,133 @@
-import { Utils }  from '@rpgjs/common'
-import { ParameterManager } from './ParameterManager'
-import { RpgPlayer } from './Player'
-import { 
-    ATK,
-    PDEF,
-    SDEF
-} from '../presets'
-import { Effect } from '@rpgjs/database'
-import { ElementManager } from './ElementManager';
-import { EffectManager } from './EffectManager';
-import { RpgServerEngine } from '../server'
+import { Constructor, RpgCommonPlayer } from "@rpgjs/common";
+import { RpgPlayer } from "./Player";
+import { ATK, PDEF, SDEF } from "../presets";
+import { Effect } from "./EffectManager";
 
-const { 
-    applyMixins
-} = Utils
+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 class BattleManager {
+export interface IBattleManager {
+  applyDamage(attackerPlayer: RpgPlayer, skill?: any): {
+    damage: number;
+    critical: boolean;
+    elementVulnerable: boolean;
+    guard: boolean;
+    superGuard: boolean;
+  };
+}
 
-    /** 
+export function WithBattleManager<TBase extends Constructor<PlayerWithMixins>>(
+  Base: TBase
+): Constructor<IBattleManager> & TBase {
+  return class extends Base implements IBattleManager {
+    /**
      * Apply damage. Player will lose HP. the `attackerPlayer` parameter is the other player, the one who attacks.
-     * 
+     *
      * If you don't set the skill parameter, it will be a physical attack.
      * The attack formula is already defined but you can customize it in the server options
-     * 
+     *
      * ```ts
      * player.applyDamage(attackerPlayer) // returns { damage: number }
      * ```
-     * 
+     *
      * @title Apply Damage
      * @method player.applyDamage(attackerPlayer,skill)
      * @param {RpgPlayer} attackerPlayer The attacking player
      * @param {any} [skill]
-     * @returns {object} 
+     * @returns {object}
      * @memberof BattleManager
      * */
-    applyDamage(attackerPlayer: RpgPlayer, skill?: any): { 
-        damage: number, 
-        critical: boolean, 
-        elementVulnerable: boolean,
-        guard: boolean,
-        superGuard: boolean
+    applyDamage(
+      attackerPlayer: RpgPlayer,
+      skill?: any
+    ): {
+      damage: number;
+      critical: boolean;
+      elementVulnerable: boolean;
+      guard: boolean;
+      superGuard: boolean;
     } {
-        const getParam = (player: RpgPlayer) => {
-            const params = {}
-            this.parameters.forEach((val, key) => {
-                params[key] = player.param[key]
-            })
-            return {
-                [ATK]: player.atk,
-                [PDEF]: player.pdef,
-                [SDEF]: player.sdef,
-                ...params
-            }
-        }
-        let damage = 0, fn
-        let critical = false
-        let guard = false
-        let superGuard = false
-        let elementVulnerable = false
-        const paramA = getParam(attackerPlayer)
-        const paramB = getParam(<any>this)
-        if (skill) {
-            fn = this.getFormulas('damageSkill')
-            if (!fn) {
-                throw new Error('Skill Formulas not exists')
-            }
-            damage = fn(paramA, paramB, skill)
+      const getParam = (player: RpgPlayer) => {
+        const params = {};
+        this.parameters.forEach((val, key) => {
+          params[key] = player.param[key];
+        });
+        return {
+          [ATK]: player.atk,
+          [PDEF]: player.pdef,
+          [SDEF]: player.sdef,
+          ...params,
+        };
+      };
+      let damage = 0,
+        fn;
+      let critical = false;
+      let guard = false;
+      let superGuard = false;
+      let elementVulnerable = false;
+      const paramA = getParam(attackerPlayer);
+      const paramB = getParam(<any>this);
+      console.log(paramA, paramB)
+      if (skill) {
+        fn = this.getFormulas("damageSkill");
+        if (!fn) {
+          throw new Error("Skill Formulas not exists");
         }
-        else {
-            fn = this.getFormulas('damagePhysic')
-            if (!fn) {
-                throw new Error('Physic Formulas not exists')
-            }
-            damage = fn(paramA, paramB)
-            const coef = this.coefficientElements(attackerPlayer)
-            if (coef >= 2) {
-                elementVulnerable = true
-            }
-            damage *= coef
-            fn = this.getFormulas('damageCritical')
-            if (fn) {
-                let newDamage = fn(damage, paramA, paramB)
-                if (damage != newDamage) {
-                    critical = true
-                }
-                damage = newDamage
-            }
+        damage = fn(paramA, paramB, skill);
+      } else {
+        fn = this.getFormulas("damagePhysic");
+        if (!fn) {
+          throw new Error("Physic Formulas not exists");
         }
-        if (this.hasEffect(Effect.GUARD)) {
-            fn = this.getFormulas('damageGuard')
-            if (fn) {
-                let newDamage = fn(damage, paramA, paramB)
-                if (damage != newDamage) {
-                    guard = true
-                }
-                damage = newDamage
-            }
+        damage = fn(paramA, paramB);
+        const coef = this.coefficientElements(attackerPlayer);
+        if (coef >= 2) {
+          elementVulnerable = true;
         }
-        if (this.hasEffect(Effect.SUPER_GUARD)) {
-            damage /= 4
-            superGuard = true
+        damage *= coef;
+        fn = this.getFormulas("damageCritical");
+        if (fn) {
+          let newDamage = fn(damage, paramA, paramB);
+          if (damage != newDamage) {
+            critical = true;
+          }
+          damage = newDamage;
         }
-        this.hp -= damage
-        return {
-            damage,
-            critical,
-            elementVulnerable,
-            guard,
-            superGuard
+      }
+      if (this.hasEffect(Effect.GUARD)) {
+        fn = this.getFormulas("damageGuard");
+        if (fn) {
+          let newDamage = fn(damage, paramA, paramB);
+          if (damage != newDamage) {
+            guard = true;
+          }
+          damage = newDamage;
         }
+      }
+      if (this.hasEffect(Effect.SUPER_GUARD)) {
+        damage /= 4;
+        superGuard = true;
+      }
+      this.hp -= damage;
+      return {
+        damage,
+        critical,
+        elementVulnerable,
+        guard,
+        superGuard,
+      };
     }
-    
+
     getFormulas(name: string) {
-        return this.server.damageFormulas[name]
+      const map = this.getCurrentMap(); 
+      return map.damageFormulas[name];
     }
+  };
 }
-
-applyMixins(BattleManager, [ParameterManager, ElementManager, EffectManager])
-
-export interface BattleManager extends ParameterManager, ElementManager, EffectManager {
-    name: string,
-    server: RpgServerEngine
- }

package/src/Player/ClassManager.ts

@@ -1,77 +1,78 @@
-import { Utils }  from '@rpgjs/common'
-import { ParameterManager } from './ParameterManager'
-import { ItemManager } from './ItemManager'
+import { Constructor, isString, RpgCommonPlayer } from "@rpgjs/common";
 
-const { 
-    applyMixins,
-    isString
-} = Utils
+type ClassClass = any;
+type ActorClass = any;
 
-type ClassClass = { new(...args: any[]) }
-type ActorClass = { new(...args: 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 class ClassManager {
+export interface IClassManager {
+  setClass(_class: ClassClass | string): ClassClass;
+  setActor(actorClass: ActorClass | string): ActorClass;
+}
 
-    _class: any
+export function WithClassManager<TBase extends Constructor<PlayerWithMixins>>(
+  Base: TBase
+): Constructor<IClassManager> & TBase {
+  return class extends Base implements IClassManager {
 
-    /** 
+    /**
      * Assign a class to the player
-     * 
+     *
      * ```ts
      * import { Fighter } from 'my-database/classes/fighter'
-     * 
+     *
      * player.setClass(Fighter)
      * ```
-     * 
+     *
      * @title Set Class
      * @method player.setClass(ClassClass)
      * @param {ClassClass | string} class class or id
-     * @returns {instance of ClassClass} 
+     * @returns {instance of ClassClass}
      * @memberof ClassManager
      * */
     setClass(_class: ClassClass | string) {
-        if (isString(_class)) _class = this.databaseById(_class)
-        this._class = new (_class as ClassClass)()
-        this['execMethod']('onSet', [this], this._class)
-        return this._class
+      if (isString(_class)) _class = this.databaseById(_class);
+      const classInstance = new (_class as ClassClass)();
+      this["execMethod"]("onSet", [this], classInstance);
+      return classInstance;
     }
 
-    /** 
+    /**
      * Allows to give a set of already defined properties to the player (default equipment, or a list of skills to learn according to the level)
-     * 
+     *
      * ```ts
      * import { Hero } from 'my-database/classes/hero'
-     * 
+     *
      * player.setActor(Hero)
      * ```
-     * 
+     *
      * @title Set Actor
      * @method player.setActor(ActorClass)
      * @param {ActorClass | string} actorClass actor class or id
-     * @returns {instance of ActorClass} 
+     * @returns {instance of ActorClass}
      * @memberof ClassManager
      * */
     setActor(actorClass: ActorClass | string) {
-        if (isString(actorClass)) actorClass = this.databaseById(actorClass)
-        const actor = new (actorClass as ActorClass)();
-        ['name', 'initialLevel', 'finalLevel', 'expCurve'].forEach(key => {
-            if (actor[key]) this[key] = actor[key]
-        })
-        for (let param in actor.parameters) {
-            this.addParameter(param, actor.parameters[param])
-        }
-        for (let item of actor.startingEquipment) {
-            this.addItem(item)
-            this.equip(item, true)
-        }
-        if (actor.class) this.setClass(actor.class)
-        this['execMethod']('onSet', [this], actor)
-        return actor
+      if (isString(actorClass)) actorClass = this.databaseById(actorClass);
+      const actor = new (actorClass as ActorClass)();
+      ["name", "initialLevel", "finalLevel", "expCurve"].forEach((key) => {
+        if (actor[key]) this[key] = actor[key];
+      });
+      for (let param in actor.parameters) {
+        this.addParameter(param, actor.parameters[param]);
+      }
+      for (let item of actor.startingEquipment) {
+        this.addItem(item);
+        this.equip(item, true);
+      }
+      if (actor.class) this.setClass(actor.class);
+      this["execMethod"]("onSet", [this], actor);
+      return actor;
     }
+  };
 }
-
-applyMixins(ClassManager, [ParameterManager, ItemManager])
-
-export interface ClassManager extends ParameterManager, ItemManager {
-    name: string
- }