@rpgjs/server 5.0.0-alpha.4 → 5.0.0-alpha.41

package/src/core/context.ts

@@ -1,3 +1,4 @@
 import { Context } from "@signe/di";
 
 export const context = new Context();
+context['side'] = 'server'

package/src/decorators/event.ts

@@ -0,0 +1,61 @@
+export enum EventMode {
+    Shared = 'shared',
+    Scenario = 'scenario'
+}
+
+export interface EventOptions {
+    /** 
+     * The mode of the event, shared evening or scenario
+     * 
+     * The scenario mode allows you to have events specific to the player. Thus, the graphics, the positions of the event will be different for each player. Beware of performance! The event is duplicated by each player.
+     * 
+     * `shared` mode by default
+     * 
+     * ```ts
+     * import { RpgEvent, EventData, RpgPlayer, EventMode } from '@rpgjs/server'
+     * @EventData({
+     *      name: 'EV-1',
+     *      mode: EventMode.Scenario // or EventMode.Shared
+     * })
+     * export class CharaEvent extends RpgEvent { }
+     * ```
+     * 
+     * @prop {string} [mode] Either "shared" or "scenario".
+     * @memberof EventData
+     * */
+    mode?: EventMode,
+
+    width?: number,
+    height?: number,
+
+    /** 
+     * The hitbox of the event. By default, this is the size of the tile of the map
+     * 
+     * @prop { { width: number, height: number }} [hitbox]
+     * @memberof EventData
+     * */
+    hitbox?: {
+        width?: number,
+        height?: number
+    },
+
+    /** 
+     * Name of the event. This is its identifier. it allows you to retrieve an event and place it on the map
+     * 
+     * @prop {string} name
+     * @memberof EventData
+     * */
+    name: string
+}
+
+export function EventData(options: EventOptions) {
+    return (target) => {
+        target.mode = options.mode || EventMode.Shared
+        target.width = options.width
+        target.height = options.height
+        target.hitbox = options.hitbox
+        target._name = options.name
+        target.prototype._name = options.name
+        target.prototype.mode = target.mode
+    }
+}

package/src/decorators/map.ts

@@ -0,0 +1,327 @@
+import type { WeatherState } from "@rpgjs/common";
+
+export interface MapOptions {
+    /** 
+     * Map identifier. Allows to go to the map (for example with player.changeMap())
+     * 
+     * @prop {string} [id]
+     * @memberof MapData
+     * */
+    id?: string,
+
+    /** 
+    * the path to the .tmx file (Tiled Map Editor)
+    * 
+    * Remember to use `require()` function
+    * 
+    * ```ts
+    * import { MapData, RpgMap } from '@rpgjs/server'
+    * 
+    * @MapData({
+    *      id: 'town',
+    *      file: require('./tmx/town.tmx')
+    * })
+    * class TownMap extends RpgMap { } 
+    * ``` 
+    * @prop {string} file
+    * @memberof MapData
+    * */
+    file?: any,
+
+    /** 
+     * The name of the map.
+     * @prop {string} [name]
+     * @memberof MapData
+     * */
+    name?: string,
+
+    /** 
+    * Map events. This is an array containing `RpgEvent` classes. 
+    * You can also give an object that will indicate the positions of the event on the map.
+    * 
+    * ```ts
+    * import { MapData, RpgMap, EventData, RpgEvent } from '@rpgjs/server'
+    * 
+    * @EventData({
+    *      name: 'Ev-1'
+    * })
+    * class NpcEvent extends RpgEvent { }
+    * 
+    * @MapData({
+    *      id: 'medieval',
+    *      file: require('./tmx/town.tmx'),
+    *      events: [NpcEvent]
+    * })
+    * class TownMap extends RpgMap {}
+    * ```
+    * 
+    * If the positions are not defined, the event will be placed on a Tiled Map Editor shape ([/guide/create-event.html#position-the-event-on-the-map](Guide)). Otherwise, it will be placed at `{x:0, y:0 }`
+    * 
+    * You can give positions:
+    * 
+    * ```ts
+    * events: [{ event: NpcEvent, x: 10, y: 30 }]
+    * ```
+    * 
+    * @prop {Class of RpgEvent[] | { event: Class RpgEvent, x: number, y: number }} [events]
+    * @memberof MapData
+    * */
+    events?: { event: any, x: number, y: number }[] | any[],
+
+    /** 
+     * The sounds that will be played when the map is open. Sounds must be defined on the client side. Then, put the name of the sound identifier
+     * 
+     * So, it is possible to play several sounds (in loop or not) on the card. You can put a background music (BGM) and a background noise (BGS) for example
+     * 
+     *  ```ts
+     * sounds: ['my-bgm', 'my-bgs']
+     * ```
+     * 
+     * And client side:
+     * 
+     * ```ts
+     * import { Sound } from '@rpgjs/client'
+     * 
+     * @Sound({
+     *      sounds: {
+     *          'my-bgm': require('./assets/bgm.ogg'),
+     *          'my-bgs': require('./assets/bgs.ogg')
+     *      },
+     *      loop: true
+     * })
+     * export class Sounds {}
+     * ```
+     * 
+     * See [https://docs.rpgjs.dev/classes/sound.html#properties](RpgSound Decorator)
+     * 
+     * @prop {Array<string>} [sounds]
+     * @memberof MapData
+     * */
+    sounds?: string[]
+
+    /**
+     * Initial weather state for this map.
+     *
+     * This value is applied when the map is loaded and can later be updated
+     * at runtime with `map.setWeather()` from server logic.
+     *
+     * ```ts
+     * @MapData({
+     *   id: 'forest',
+     *   file: require('./tmx/forest.tmx'),
+     *   weather: {
+     *     effect: 'fog',
+     *     preset: 'rpgForestFog',
+     *     params: { density: 1.2, height: 0.75 },
+     *     transitionMs: 1200
+     *   }
+     * })
+     * class ForestMap extends RpgMap {}
+     * ```
+     */
+    weather?: WeatherState | null
+
+    /** 
+     * Whether to stop all sounds before playing the map sounds when a player joins.
+     * 
+     * If set to `true`, all currently playing sounds will be stopped before playing the new map sounds.
+     * This prevents sound overlap when changing maps.
+     * 
+     * By default, this is `false`, meaning sounds from the previous map will continue playing.
+     * 
+     * ```ts
+     * @MapData({
+     *     id: 'battle-map',
+     *     sounds: ['battle-theme'],
+     *     stopAllSoundsBeforeJoin: true // Stop all sounds before playing battle theme
+     * })
+     * class BattleMap extends RpgMap {}
+     * ```
+     * 
+     * @prop {boolean} [stopAllSoundsBeforeJoin=false]
+     * @memberof MapData
+     * @since 5.0.0
+     * */
+    stopAllSoundsBeforeJoin?: boolean
+
+    /** 
+     * Specify which properties will be synchronized with the client. On the client side, you can retrieve the values synchronized with the valueChanges property on the scene
+     * 
+     * You must create the schema:
+     * 
+     * ```ts
+     * import { MapData, RpgMap } from '@rpgjs/server'
+     * 
+     * @MapData({
+     *      id: 'medieval',
+     *      file: require('./tmx/town.tmx'),
+     *      syncSchema: {
+     *          count: Number
+     *      }
+     * })
+     * export class TownMap extends RpgMap {
+     *      count: number = 0
+     * 
+     *      onLoad() {}
+     * 
+     *      onJoin() {
+     *          this.count++
+     *      }
+     * 
+     *      onLeave(player) {
+     *          super.onLeave(player)
+     *          this.count--
+     *      }
+     * }
+     * 
+     * ```
+     * 
+     * If you want to change the scheme of players and events, consider overwriting the existing scheme
+     * 
+     *  ```ts
+     * import { MapData, RpgMap, RpgPlayer } from '@rpgjs/server'
+     * 
+     * 
+     * declare module '@rpgjs/server' {
+     *  export interface RpgPlayer {
+     *      customProp: string
+     *  }
+     * }
+     * 
+     * @MapData({
+     *      id: 'medieval',
+     *      file: require('./tmx/town.tmx'),
+     *      syncSchema: {
+     *          users: [
+     *              {
+     *                  customProp: String,
+     *                  ...RpgPlayer.schemas
+     *              }
+     *          ]
+     *      }
+     * })
+     * export class TownMap extends RpgMap {}
+     * ```
+     * 
+     * The properties are called `users` and `events`. Their scheme is identical and defined in `RpgPlayer.schemas`. To write schematics, refer to the [documentation of the simple-room](https://github.com/RSamaium/simple-room) module
+     * 
+     * @prop {object} [syncSchema]
+     * @memberof MapData
+     * */
+    syncSchema?: any
+
+    /** 
+     * Decreases the RAM of the map. In this case, some instructions will be different.
+     * 
+     * `map.getTileByIndex()` will not return all tiles of an index but only the tile of the highest layer
+     * 
+     * > You can also use the `low-memory` property in Tiled maps
+     * 
+     * @prop {boolean} [lowMemory=false]
+     * @since 3.1.0
+     * @memberof MapData
+     * */
+    lowMemory?: boolean
+
+    /** 
+     * Called when the map is loaded and initialized
+     * 
+     * This hook is executed once when the map data is loaded and ready.
+     * Use this to initialize map-specific properties or setup.
+     * 
+     * @prop { () => any } [onLoad]
+     * @memberof MapData
+     * @example
+     * ```ts
+     * @MapData({
+     *     id: 'town',
+     *     file: require('./tmx/town.tmx'),
+     *     onLoad() {
+     *         console.log('Town map loaded')
+     *         // Initialize map properties
+     *     }
+     * })
+     * class TownMap extends RpgMap {}
+     * ```
+     * */
+    onLoad?: () => any
+
+    /** 
+     * Called when a player joins the map
+     * 
+     * This hook is executed each time a player joins the map.
+     * Use this to perform actions when a player enters the map.
+     * 
+     * @prop { (player: RpgPlayer) => any } [onJoin]
+     * @memberof MapData
+     * @example
+     * ```ts
+     * @MapData({
+     *     id: 'town',
+     *     file: require('./tmx/town.tmx'),
+     *     onJoin(player: RpgPlayer) {
+     *         console.log(`${player.name} joined the town`)
+     *         // Perform actions when player joins
+     *     }
+     * })
+     * class TownMap extends RpgMap {}
+     * ```
+     * */
+    onJoin?: (player: RpgPlayer) => any
+
+    /** 
+     * Called when a player leaves the map
+     * 
+     * This hook is executed each time a player leaves the map.
+     * Use this to perform cleanup or actions when a player exits the map.
+     * 
+     * @prop { (player: RpgPlayer) => any } [onLeave]
+     * @memberof MapData
+     * @example
+     * ```ts
+     * @MapData({
+     *     id: 'town',
+     *     file: require('./tmx/town.tmx'),
+     *     onLeave(player: RpgPlayer) {
+     *         console.log(`${player.name} left the town`)
+     *         // Perform cleanup when player leaves
+     *     }
+     * })
+     * class TownMap extends RpgMap {}
+     * ```
+     * */
+    onLeave?: (player: RpgPlayer) => any
+}
+
+export function MapData(options: MapOptions) {
+    return (target) => {
+        target.file = options.file
+        target.id = options.id
+        target.type = 'map'
+        target.prototype.name = options.name
+        target.prototype.file = options.file
+        target.prototype.id = options.id
+        target.prototype.sounds = options.sounds
+        target.prototype.weather = options.weather
+        target.prototype.lowMemory = options.lowMemory
+        target.prototype.stopAllSoundsBeforeJoin = options.stopAllSoundsBeforeJoin
+
+        target.prototype.$schema = {}
+
+        if (options.syncSchema) {
+            target.prototype.$schema = options.syncSchema
+        }
+        target.prototype._events = options.events
+        
+        // Store hooks on prototype
+        if (options.onLoad) {
+            target.prototype.onLoad = options.onLoad
+        }
+        if (options.onJoin) {
+            target.prototype.onJoin = options.onJoin
+        }
+        if (options.onLeave) {
+            target.prototype.onLeave = options.onLeave
+        }
+    }
+}

package/src/index.ts

@@ -4,6 +4,16 @@ export * from "./RpgServer";
 export * from "./core/setup";
 export * from "./core/inject";
 export * from "./Player/Player";
+export * from "./Player/Components";
 export * from "./module";
 export * from "./rooms/map";
-export * from "./presets";
+export * from "./presets";
+export * from "@signe/reactive";
+export * from "./Gui";
+export * from "./services/save";
+export * from "./storage";
+export { RpgShape, RpgModule, MAXHP, MAXSP, ATK, PDEF, SDEF, STR, AGI, INT, DEX } from "@rpgjs/common";
+export * from "./decorators/event";
+export * from "./decorators/map";
+export * from "./Player/MoveManager";
+export * from "./presets";

package/src/logs/log.ts

@@ -1,3 +1,10 @@
-export class Log {
-    constructor(private id: string, private msg: string) {}
-}
+export class Log extends Error {
+  readonly id: string;
+
+  constructor(id: string, msg: string) {
+    super(`[${id}] ${msg}`);
+    this.name = "RpgLog";
+    this.id = id;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/src/module.ts

@@ -2,15 +2,80 @@ import { findModules, provideModules } from "@rpgjs/common";
 import { FactoryProvider } from "@signe/di";
 import { RpgServerEngine } from "./RpgServerEngine";
 import { RpgMap } from "./rooms/map";
+import { RpgPlayer } from "./Player/Player";
+import { RpgServer } from "./RpgServer";
 
-export function provideServerModules(modules: any[]): FactoryProvider {
+/**
+ * Type for server modules that can be either:
+ * - An object implementing RpgServer interface
+ * - A class decorated with @RpgModule decorator
+ */
+export type RpgServerModule = RpgServer | (new () => any);
+
+/**
+ * Provides server modules configuration to Angular Dependency Injection
+ * 
+ * This function accepts an array of server modules that can be either:
+ * - Objects implementing the RpgServer interface
+ * - Classes decorated with the @RpgModule decorator (which will be instantiated)
+ * 
+ * @param modules - Array of server modules (objects or classes)
+ * @returns FactoryProvider configuration for Angular DI
+ * @example
+ * ```ts
+ * // Using an object
+ * provideServerModules([
+ *   {
+ *     player: {
+ *       onConnected(player) {
+ *         console.log('Player connected')
+ *       }
+ *     }
+ *   }
+ * ])
+ * 
+ * // Using a decorated class
+ * @RpgModule<RpgServer>({
+ *   engine: {
+ *     onStart(server) {
+ *       console.log('Server started')
+ *     }
+ *   }
+ * })
+ * class MyServerModule {}
+ * 
+ * provideServerModules([MyServerModule])
+ * ```
+ */
+export function provideServerModules(modules: RpgServerModule[]): FactoryProvider {
   return provideModules(modules, "server", (modules, context) => {
     const mainModuleServer = findModules(context, 'Server')
     modules = [...mainModuleServer, ...modules]
     modules = modules.map((module) => {
+      // If module is a class (constructor function), instantiate it
+      // The RpgModule decorator adds properties to the prototype, which will be accessible via the instance
+      if (typeof module === 'function') {
+        const instance = new module() as any;
+        // Copy all enumerable properties (including from prototype) to a plain object
+        const moduleObj: any = {};
+        for (const key in instance) {
+          moduleObj[key] = instance[key];
+        }
+        module = moduleObj;
+      }
       if ('server' in module) {
         module = module.server as any;
       }
+      if (module.player?.props) {
+        module = {
+          ...module,
+          playerProps: {
+            load: (player: RpgPlayer) => {
+              player.setSync(module.player.props)
+            },
+          }
+        };
+      }
       if (module.maps && Array.isArray(module.maps)) {
         const maps = [...module.maps];
         module = {
@@ -18,15 +83,73 @@ export function provideServerModules(modules: any[]): FactoryProvider {
           maps: {
             load: (engine: RpgMap) => {
               maps.forEach((map) => {
-                engine.maps.push(map);
+                // If map is a class (constructor function), extract properties from class and prototype
+                // Otherwise, use the object directly
+                let mapInstance: any;
+                if (typeof map === 'function') {
+                  // Extract properties from the class (static properties set by @MapData decorator)
+                  // and from the prototype (instance properties like _events)
+                  // The decorator sets properties on both the class and prototype, so we check both
+                  const MapClass = map as any;
+                  mapInstance = {
+                    id: MapClass.prototype?.id ?? MapClass.id,
+                    file: MapClass.prototype?.file ?? MapClass.file,
+                    type: MapClass.type,
+                    name: MapClass.prototype?.name,
+                    sounds: MapClass.prototype?.sounds,
+                    weather: MapClass.prototype?.weather,
+                    lowMemory: MapClass.prototype?.lowMemory,
+                    stopAllSoundsBeforeJoin: MapClass.prototype?.stopAllSoundsBeforeJoin,
+                    events: MapClass.prototype?._events,
+                    syncSchema: MapClass.prototype?.$schema,
+                    onLoad: MapClass.prototype?.onLoad,
+                    onJoin: MapClass.prototype?.onJoin,
+                    onLeave: MapClass.prototype?.onLeave,
+                  };
+                } else {
+                  mapInstance = map;
+                }
+                engine.maps.push(mapInstance);
+              });
+            },
+          }
+        };
+      }
+      if (module.worldMaps && Array.isArray(module.worldMaps)) {
+        const worldMaps = [...module.worldMaps];
+        module = {
+          ...module,
+          worldMaps: {
+            load: (engine: RpgMap) => {
+              worldMaps.forEach((worldMap) => {
+                engine.createDynamicWorldMaps(worldMap)
               });
             },
           }
         };
       }
+      if (module.database) {
+        const database = module.database;
+        module = {
+          ...module,
+          databaseHooks: {
+            load: async (engine: RpgMap) => {
+              const data = typeof database === 'function'
+                ? await database(engine)
+                : database;
+              if (!data || typeof data !== 'object') {
+                return;
+              }
+              for (const key in data) {
+                engine.addInDatabase(key, data[key]);
+              }
+            },
+          }
+        };
+      }
       return module;
     })
     return modules
   });
 }
- 
+ 

package/src/presets/index.ts

@@ -1,14 +1,5 @@
 import { random } from "@rpgjs/common"
-
-export const MAXHP: string = 'maxHp'
-export const MAXSP: string = 'maxSp'
-export const ATK: string = 'atk'
-export const PDEF: string = 'pdef'
-export const SDEF: string = 'sdef'
-export const STR: string = 'str'
-export const AGI: string = 'agi'
-export const INT: string = 'int'
-export const DEX: string = 'dex'
+import { DEX, AGI, ATK, PDEF, SDEF, STR, INT } from "@rpgjs/common"
 
 export const MAXHP_CURVE = {
     start: 741,