@rpgjs/server 3.3.2 → 4.0.0-beta.3

package/src/Scenes/Map.ts

@@ -0,0 +1,302 @@
+
+import { HookServer, RpgCommonMap, RpgPlugin, Utils } from '@rpgjs/common'
+import { World } from 'simple-room'
+import { isTiledFormat, TiledMap } from '@rpgjs/tiled'
+import { MapOptions, MapData } from '../decorators/map'
+import { RpgMap } from '../Game/Map'
+import { RpgWorldMaps, WorldMap } from '../Game/WorldMaps'
+import { RpgEvent, RpgPlayer } from '../Player/Player'
+import { RpgServerEngine } from '../server'
+
+export interface RpgClassMap<T> {
+    id?: string
+    file?: string
+    new(server: any): T,
+}
+
+type SceneMapObject = {
+    maps: any[],
+    worldMaps: WorldMap[]
+    events: RpgEvent[]
+}
+
+export class SceneMap {
+    static readonly id: string = 'map'
+
+    private maps: any[] = []
+    private mapsById: {
+        [mapId: string]: RpgClassMap<RpgMap>
+    } = {}
+    private worldMaps: Map<string, RpgWorldMaps> = new Map()
+
+    constructor(sceneMapObject: SceneMapObject, private server: RpgServerEngine) {
+        const { maps, worldMaps, events } = sceneMapObject
+        this.maps = maps
+        this.mapsById = {}
+        RpgCommonMap.buffer.clear()
+        if (this.maps) {
+            for (let map of this.maps) {
+                this.createDynamicMap(map)
+            }
+        }
+        if (worldMaps) {
+            for (let worldMap of worldMaps) {
+                this.createDynamicWorldMaps(worldMap)
+            }
+        }
+    }
+
+    /**
+     * Returns an array of RpgClassMap objects that represent maps with static properties.
+     * @returns {RpgClassMap<RpgMap>[]} Array of RpgClassMap objects.
+     * @since 4.0.0
+     * @example
+     * ```typescript
+     * const maps = scene.getMaps();
+     * console.log(maps);
+     * // Output: [
+     * // { file: 'maps/level1.tmx', id: 'level1', type: 'map' },
+     * // { file: 'maps/level2.tmx', id: 'level1', type: 'map' },
+     * // { file: 'maps/level3.tmx', id: 'level1', type: 'map' }
+     * // ]
+     * ```
+     * @memberof SceneMap
+     */
+    getMaps(): RpgClassMap<RpgMap>[] {
+        return Object.values(this.mapsById)
+    }
+
+    getMapBydId(id: string): RpgClassMap<RpgMap> | null {
+        let mapClass = this.mapsById[id]
+        if (!mapClass) {
+            return null
+        }
+        if (!Utils.isClass(mapClass)) mapClass = Utils.createConstructor<RpgClassMap<RpgMap>>(mapClass)
+        return mapClass
+    }
+
+    async loadMap(id: string): Promise<RpgMap | undefined> {
+        const mapClass = this.getMapBydId(id)
+
+        if (!mapClass) {
+            console.log(`Map ${id} not exists`)
+            return
+        }
+
+        let mapInstance
+
+        if (mapClass['buffer'].has(id)) {
+            return mapClass['buffer'].get(id)
+        }
+
+        if (RpgCommonMap.buffer.has(id)) {
+            mapInstance = RpgCommonMap.buffer.get(id)
+        }
+        else {
+            const room = new mapClass(this.server)
+            room.$schema.users = [
+                {
+                    ...RpgPlayer.schemas,
+                    ...this.server['playerProps']
+                }
+            ]
+            mapInstance = World.addRoom(id, room)
+            await mapInstance.load()
+        }
+
+        return mapInstance
+    }
+
+    /**
+    * Loads the content of a `.world` file from Tiled Map Editor into the map scene
+    * 
+    * > Note, that if the map already exists (i.e. you have already defined an RpgMap), the world will retrieve the already existing map. Otherwise it will create a new map
+    * 
+    * @title Create worlds dynamically
+    * @method sceneMap.createDynamicWorldMaps(world)
+    * @param {object} world 
+    * object is 
+    * ```ts
+    * {
+    *  id?: string
+    *  maps: {
+    *      id?: string
+    *      properties?: object
+    *      fileName: string;
+           height: number;
+           width: number;
+           x: number;
+           y: number;
+    *  }[],
+       onlyShowAdjacentMaps: boolean, // only for Tiled Map Editor
+       type: 'world' // only for Tiled Map Editor
+    * }
+    * ```
+    * 
+    * @since 3.0.0-beta.8
+    * @memberof SceneMap
+    */
+    createDynamicWorldMaps(world: WorldMap): RpgWorldMaps {
+        world.id = world.id || Utils.generateUID()
+        const worldMap = new RpgWorldMaps(world.id).load(world, this)
+        this.worldMaps.set(world.id, worldMap)
+        return worldMap
+    }
+
+    /**
+     * Recover a world
+     * 
+     * @title Recover a world
+     * @method sceneMap.getWorldMaps(id)
+     * @param {string} id world id 
+     * @return { RpgWorldMaps | undefined }
+     * @since 3.0.0-beta.8
+     * @memberof SceneMap
+     */
+    getWorldMaps(id: string): RpgWorldMaps | undefined {
+        return this.worldMaps.get(id)
+    }
+
+    /**
+    * Delete a world
+    * 
+    * @title Delete a world
+    * @method sceneMap.deleteWorldMaps(id)
+    * @param {string} id world id 
+    * @since 3.0.0-beta.8
+    * @memberof SceneMap
+    */
+    deleteWorldMaps(id: string): void {
+        this.worldMaps.delete(id)
+    }
+
+    /**
+     * Create a dynamic map
+     * 
+     * Since version 3.0.0-beta.8, you can just pass the path to the file. The identifier will then be the name of the file
+     * 
+     * @method sceneMap.createDynamicMap(mapData)
+     * @title Create a dynamic map
+     * @param {object | RpgMap | string} mapData The same property as [@MapData decorator](https://docs.rpgjs.dev/classes/map.html#mapdata-decorator)
+     * @returns {RpgMap}
+     * @since 3.0.0-beta.4
+     * @memberof SceneMap
+     * @example
+     * ```ts
+     * sceneMap.createDynamicMap({
+     *      id: 'myid',
+     *      file: require('./tmx/mymap.tmx')
+     * })
+     * ```
+     * 
+     * And later, on the player:
+     * 
+     * ```ts
+     * player.changeMap('myid')
+     * ```
+     * 
+     * --- 
+     * 
+     * since beta.8
+     * 
+     * ```ts
+     * sceneMap.createDynamicMap(require('./tmx/mymap.tmx')) // id is "mymap"
+     * ```
+     */
+    createDynamicMap(mapData: MapOptions | string | RpgClassMap<RpgMap> | TiledMap): RpgClassMap<RpgMap> | never {
+        if (Utils.isString(mapData)) {
+            const id = Utils.extractId(mapData as string)
+            if (!id) {
+                throw new Error('Unable to extract the file identifier. Check that the file has only the following characters: [a-zA-Z0-9-_$!]+')
+            }
+            mapData = {
+                id: id[1],
+                file: mapData
+            } as MapOptions
+        }
+        if (isTiledFormat(mapData)) {
+            const tiledData = (mapData as TiledMap)
+            mapData = {
+                file: { ...tiledData }
+            } as MapOptions
+        }
+        if (!(mapData as MapOptions).id) (mapData as MapOptions).id = Utils.generateUID()
+        if (!Utils.isClass(mapData)) {
+            @MapData(mapData as MapOptions)
+            class DynamicMap extends RpgMap { }
+            mapData = DynamicMap
+        }
+        const map: RpgClassMap<RpgMap> = mapData as any
+        this.mapsById[map.id as string] = map
+        return map
+    }
+
+    async changeMap(
+        mapId: string,
+        player: RpgPlayer,
+        positions?: { x: number, y: number, z?: number } | string
+    ): Promise<RpgMap | null | boolean> {
+
+        const boolArray: boolean[] = await RpgPlugin.emit(HookServer.PlayerCanChangeMap, [player, this.getMapBydId(mapId)], true)
+
+        if (boolArray.some(el => el === false)) {
+            return null
+        }
+
+        // if just teleport, not change map
+        if (player.map === mapId) {
+            await player.teleport(positions || 'start')
+            return null
+        }
+
+        player.emit('preLoadScene', mapId)
+
+        player.prevMap = player.map
+
+        if (player.prevMap) {
+            await player.execMethod('onLeaveMap', <any>[player.getCurrentMap()])
+            World.leaveRoom(player.prevMap, player.id)
+        }
+
+        player.map = mapId
+        player.events = {}
+        player.tmpPositions = positions as any
+
+        const scalabilityArray: boolean[] = await RpgPlugin.emit(HookServer.ScalabilityChangeServer, player)
+
+        if (scalabilityArray.some(el => el === true)) {
+            return true
+        }
+
+        player.tmpPositions = null
+
+        const mapInstance = await this.loadMap(mapId)
+
+        if (!mapInstance) return null
+
+        if (!player.height) player.height = mapInstance.tileHeight
+        if (!player.width) player.width = mapInstance.tileWidth
+        if (!player.hitbox.h) player.hitbox.h = mapInstance.tileHeight
+        if (!player.hitbox.w) player.hitbox.w = mapInstance.tileWidth
+
+        player.emitSceneMap()
+
+        // if room is removed after load map (for unit tests)
+        if (!World.getRoom(mapId)) {
+            return null
+        }
+
+        player.teleport(positions || 'start')
+
+        World.joinRoom(mapId, player.id)
+
+        player = World.getUser(player.id) as RpgPlayer
+
+        if (player) {
+            player.createDynamicEvent(<any>mapInstance._events, false)
+            await player.execMethod('onJoinMap', <any>[mapInstance])
+        }
+
+        return mapInstance
+    }
+}

package/src/decorators/event.ts

@@ -0,0 +1,57 @@
+import { EventMode } from '../Player/Player'
+
+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
+    }
+}

package/src/decorators/map.ts

@@ -0,0 +1,223 @@
+import { TiledMap } from '@rpgjs/tiled'
+import { componentSchema, RpgPlayer } from '../Player/Player'
+
+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: string | TiledMap,
+
+    /** 
+     * 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[]
+
+    /** 
+     * 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
+     * 
+     *      onEnter() {
+     *          this.count++
+     *      }
+     * 
+     *      onLeave() {
+     *          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
+}
+
+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.lowMemory = options.lowMemory
+
+        target.prototype.$schema = {}
+
+        if (options.syncSchema) {
+            target.prototype.$schema = options.syncSchema
+        }
+        if (!target.prototype.$schema.shapes) {
+            target.prototype.$schema.shapes = [
+                {
+                    type: String,
+                    name: String,
+                    x: Number,
+                    y: Number,
+                    width: Number,
+                    height: Number,
+                    properties: {
+                        collision: Boolean
+                    },
+                    polygon: [{ x: Number, y: Number }],
+                    rotation: Number,
+                    components: [componentSchema]
+                }
+            ]
+        }
+        if (!target.prototype.$schema.users) {
+            target.prototype.$schema.users = [RpgPlayer.schemas]
+        }
+        if (!target.prototype.$schema.events) {
+            target.prototype.$schema.events = [RpgPlayer.schemas]
+        }
+
+        target.prototype._events = options.events
+    }
+}

package/src/entry-point.ts

@@ -0,0 +1,102 @@
+import { RpgCommonGame, HookServer, loadModules, ModuleType, GameSide, RpgPlugin } from '@rpgjs/common'
+import { RpgServerEngine } from './server'
+import { RpgPlayer } from './Player/Player'
+import { RpgMatchMaker } from './MatchMaker'
+
+interface RpgServerEntryPointOptions {
+    /** 
+    * Represents socket io but you can put something else (which is of the same scheme as socket io)
+    * 
+    * @prop {SocketIO or other} io
+    * @memberof RpgServerEntryPoint
+    * */
+    io: any,
+    /** 
+     * It allows you to know where the maps are located. Usually put `__dirname` for the current directory.
+     * 
+     * ```ts
+     * basePath: __dirname
+     * ``` 
+     * 
+     * @prop {string} basePath
+     * @memberof RpgServerEntryPoint
+     * */
+    basePath: string
+
+    standalone?: boolean
+
+    /** 
+   * The general configurations of the game.
+   * 
+   * @prop {object} [globalConfig]
+   * @memberof RpgServerEntryPoint
+   * */
+    globalConfig?: any
+
+    workers?: any
+}
+
+export default async function (modules: ModuleType[], options: RpgServerEntryPointOptions): Promise<RpgServerEngine> {
+    const gameEngine = new RpgCommonGame(GameSide.Server)
+
+    if (!options.globalConfig) options.globalConfig = {}
+
+    const relations = {
+        onConnected: HookServer.PlayerConnected,
+        onInput: HookServer.PlayerInput,
+        onJoinMap: HookServer.PlayerJoinMap,
+        onLeaveMap: HookServer.PlayerLeaveMap,
+        onLevelUp: HookServer.PlayerLevelUp,
+        onDead: HookServer.PlayerDead,
+        onDisconnected: HookServer.PlayerDisconnected,
+        onInShape: HookServer.PlayerInShape,
+        onOutShape: HookServer.PlayerOutShape,
+        onMove: HookServer.PlayerMove,
+        canChangeMap: HookServer.PlayerCanChangeMap
+    }
+
+    const relationsEngine = {
+        onStart: HookServer.Start,
+        onStep: HookServer.Step
+    }
+
+    const { playerProps } = await loadModules(modules, {
+        side: 'server',
+        relations: {
+            player: relations,
+            engine: relationsEngine,
+            scalability: {
+                onConnected: HookServer.ScalabilityPlayerConnected,
+                doChangeServer: HookServer.ScalabilityChangeServer
+            }
+        }
+    }, (mod) => {
+        const { scalability } = mod
+        if (scalability) {
+            const { hooks, stateStore, matchMaker } = scalability
+            const matchMakerInstance = new RpgMatchMaker(matchMaker)
+            RpgPlugin.on(HookServer.Start, () => {
+                return stateStore.connect()
+            })
+            mod.scalability._hooks = {}
+            for (let hookName in hooks) {
+                let originalHook = mod.scalability.hooks[hookName]
+                mod.scalability._hooks[hookName] = function (player: RpgPlayer) {
+                    return originalHook(stateStore, matchMakerInstance, player)
+                }
+            }
+        }
+        return mod
+    })
+
+    const serverEngine = new RpgServerEngine(options.io, gameEngine, {
+        debug: {},
+        updateRate: 10,
+        stepRate: 60,
+        timeoutInterval: 0,
+        countConnections: false,
+        playerProps,
+        ...options
+    })
+    return serverEngine
+}