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

package/dist/decorators/map.d.ts

@@ -0,0 +1,299 @@
+import { WeatherState } from '../../../common/src';
+import { 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 declare function MapData(options: MapOptions): (target: any) => void;

package/dist/index.d.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 '@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 '../../common/src';
+export * from './decorators/event';
+export * from './decorators/map';
+export * from './Player/MoveManager';
+export * from './presets';