@rpgjs/server 5.0.0-alpha.9 → 5.0.0-beta.1

package/src/decorators/map.ts

@@ -0,0 +1,343 @@
+import type { WeatherState } from "@rpgjs/common";
+import type { MapEventDefinition, MapEventPlacement } from "../rooms/map";
+
+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 }]
+    * ```
+    *
+    * For object-based events, put the hooks in the `event` property and keep map placement
+    * (`x`, `y`, `id`) at the wrapper level:
+    *
+    * ```ts
+    * events: [{
+    *   x: 200,
+    *   y: 120,
+    *   event: {
+    *     onInit() {
+    *       this.setGraphic('female')
+    *     }
+    *   }
+    * }]
+    * ```
+    * 
+    * @prop {(MapEventDefinition | MapEventPlacement)[]} [events]
+    * @memberof MapData
+    * */
+    events?: (MapEventDefinition | MapEventPlacement)[],
+
+    /** 
+     * 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
   });
 }
- 
+