@rpgjs/server 4.3.0 → 5.0.0-alpha.1

package/src/MatchMaker.ts

@@ -1,65 +0,0 @@
-
-import axios from 'axios'
-import { Utils } from '@rpgjs/common'
-import { RpgPlayer } from './Player/Player'
-import { inject } from './inject'
-import { RpgServerEngine } from './server'
-
-interface MatchMakerPayload {
-    playerId: string
-    mapName: string
-}
-
-export interface MatchMakerResponse {
-    url: string
-    port: number
-    serverId: string
-}
-
-export interface MatchMakerOption {
-    endpoint?: string
-    headers?: any
-    callback?: (payload: MatchMakerPayload) => MatchMakerResponse
-}
-
-export class RpgMatchMaker {
-    private endpoint?: string
-    private headers?: any
-    private callback?: (payload: MatchMakerPayload) => MatchMakerResponse
-
-    constructor(private options: MatchMakerOption) {
-        this.endpoint = options.endpoint
-        this.headers = options.headers
-        this.callback = options.callback
-    }
-
-    async getServer(player: RpgPlayer): Promise<MatchMakerResponse | null> {
-        const currentServerId = inject(RpgServerEngine).serverId
-        const payload: MatchMakerPayload = {
-            playerId: player.id,
-            mapName: player.map
-        }
-        let res = {} as MatchMakerResponse
-        if (this.callback) {
-            res = this.callback(payload)
-            if (Utils.isPromise(res)) {
-                res = await res
-            }
-        }
-        if (this.endpoint) {
-            try {
-                res = await axios.post<MatchMakerResponse>(this.endpoint, payload, {
-                    headers: this.headers
-                }).then(res => res.data)
-            }
-            catch (err) {
-                console.log('There is a problem with the MatchMaker webservice.')        
-                throw err
-            }
-        }
-        if (currentServerId == res.serverId) {
-            return null
-        }
-        return res
-    }
-}

package/src/Monitor/index.ts

@@ -1,78 +0,0 @@
-import { EventEmitter } from '@rpgjs/common'
-import os from 'os'
-
-class Monitor extends EventEmitter {
-    private monitors: Map<string, any> = new Map()
-    private lastTime: any
-    loopMs
-    totalConnected: number = 0
-
-    get status() {
-        return {
-            loop: this.loopMs,
-            totalConnected: this.totalConnected
-        }
-    }
-
-    getStatusOf(id) {
-        return this.monitors.get(id)
-    }
-
-    update(server) {
-        const { scheduler, options } = server
-        if (this.lastTime) {
-            const hrtime = process.hrtime(this.lastTime)
-            this.loopMs = hrtime[1] / 1e6
-        }
-        const period = scheduler.options.period
-        if (this.loopMs > period + 20) {
-            const { stepRate } = options
-            console.warn('%s - Warning Low FPS. %s players connected. Game Loop: %s FPS', new Date(), this.totalConnected, Math.round(stepRate / (this.loopMs / period)))
-        }
-        this.lastTime = process.hrtime()
-    }
-
-    addMonitor(socket) {
-        // TODO
-        /*
-        let bytesIn = 0 
-        let bytesOut = 0
-        const update = () => {
-            this.monitors.set(id, {
-                bytesIn: bytesIn.toFixed(2),
-                bytesOut: bytesOut.toFixed(2)
-            })
-        }
-        const id = socket.id
-        socket.use((packet, next) => {
-            const size = ('42'+JSON.stringify(packet)).length
-            bytesIn += size
-            update()
-            this.emit('update', this.monitors.get(id))
-            next()
-        })
-        socket._emit = socket.emit.bind(socket)
-        socket.emit = (name, data) => {
-            let size = 0
-            let obj = data
-            if (name == 'worldUpdate') {
-                obj = Object.assign({}, data)
-                size += Buffer.byteLength(obj.dataBuffer)
-                obj.dataBuffer = {_placeholder: true, num: 0}
-            }
-            size += `451-["${name},${JSON.stringify(obj)}"]`.length
-            bytesOut += size
-            update()
-            return socket._emit(name, data) 
-        }
-        */
-        this.totalConnected++
-    }
-
-    removeMonitor(id) {
-        this.monitors.delete(id)
-        this.totalConnected--
-    }
-}
-
-export default new Monitor()

package/src/Query.ts

@@ -1,172 +0,0 @@
-import { World } from 'simple-room'
-import { RpgShape, Utils } from '@rpgjs/common'
-import { RpgPlayer } from './Player/Player'
-import { Observable } from 'rxjs'
-
-const { isString } = Utils
-
-class QueryClass {
-    /** 
-     * Listen to the changes on all the rooms
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * import { map } from 'rxjs/operators' // install rxjs
-     * 
-     * RpgWorld.changes
-     *  .pipe(
-     *      map(rooms => rooms['mymap'])
-     *  )
-     *  .subscribe((room) => {
-     *      const users: any = Object.values(room.users)
-     *      console.log(users)
-     *  })
-     * ``` 
-     * 
-     * @title Subscribe to the world
-     * @prop {Observable} RpgWorld.changes
-     * @memberof RpgWorld
-     * */
-    get changes(): Observable<any> {
-        return World.changes.asObservable() as any
-    }
-
-    /**
-     * Retrieve a player according to his ID
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * 
-     * const player = RpgWorld.getPlayer(player) // player is RpgPlayer (player.id) or string (id)
-     * ```
-     * 
-     * @title Get Player
-     * @method RpgWorld.getPlayer(player)
-     * @param {RpgPlayer | string} player identifier
-     * @returns {RpgPlayer}
-     * @memberof RpgWorld
-     */
-    getPlayer(player: RpgPlayer | string): RpgPlayer {
-        const id: any = isString(player) ? player : '' + (player as RpgPlayer).id
-        const _player: any = World.getUser(id)
-        return _player as RpgPlayer
-    }
-
-    /**
-     * Recover all the players of the game
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * 
-     * const players = RpgWorld.getPlayers()
-     * ```
-     * 
-     * @title Get all Players
-     * @method RpgWorld.getPlayers()
-     * @returns {Array<RpgPlayer>}
-     * @memberof RpgWorld
-     */
-    getPlayers(): RpgPlayer[] {
-        const users: any = World.getUsers()
-        const array = Object.values(users) as RpgPlayer[]
-        return array.map((user: RpgPlayer) => this.getPlayer(user))
-    }
-
-    /**
-     * Recover all map objects: players and events. If you specify the `player` parameter, it also retrieves the events in scenario mode of the player in question
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * 
-     * const objects = RpgWorld.getObjectsOfMap('mapname')
-     * console.log(objects)
-     * ```
-     * 
-     * Also retrieve events in Scenario mode:
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * 
-     * const objects = RpgWorld.getObjectsOfMap('mapname', 'playerid')
-     * ```
-     * 
-     * @title Get all objects of map
-     * @method RpgWorld.getObjectsOfMap(map,playerId?)
-     * @param {string} map Map Name
-     * @param {RpgPlayer | string} playerId player identifier
-     * @returns {Array<RpgPlayer>}
-     * @memberof RpgWorld
-     */
-    getObjectsOfMap(map: string, playerId?: RpgPlayer | string): RpgPlayer[] {
-        return Object.values(this._getObjectsOfMap(map, playerId)) as RpgPlayer[]
-    }
-
-    _getObjectsOfMap(map: string, playerId?: RpgPlayer | string): { [id: string]: RpgPlayer } {
-        const room: any = World.getRoom(map)
-        let player: any = null
-        if (playerId) {
-            player = this.getPlayer(playerId)
-        }
-        return {
-            ...room.users,
-            ...room.events,
-            ...(player ? player.events : {})
-        }
-    }
-
-    /**
-     * Find all the shapes of the map
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * 
-     * const shapes = RpgWorld.getShapesOfMap('mapname')
-     * console.log(shapes)
-     * ```
-     * 
-     * @title Get all shapes of map
-     * @method RpgWorld.getShapesOfMap(map)
-     * @param {string} map Map Name
-     * @returns {Array<RpgShape>}
-     * @memberof RpgWorld
-     */
-    getShapesOfMap(map: string): RpgShape[] {
-        return Object.values(this._getShapesOfMap(map))
-    }
-
-    _getShapesOfMap(map: string): { [id: string]: RpgShape } {
-        const room: any = World.getRoom(map)
-        return room.shapes
-    }
-
-    // TODO
-    getRooms<T>(): Map<string, T> {
-        return World.getRooms() as Map<string, T>
-    }
-
-    getRoom<T>(name: string): T {
-        return World.getRoom(name) as T
-    }
-
-    /**
-     * Recover all the players of a map
-     * 
-     * ```ts
-     * import { RpgWorld } from '@rpgjs/server'
-     * 
-     * const players = RpgWorld.getPlayersOfMap('mapname')
-     * ```
-     * 
-     * @title Get all Players a map
-     * @method RpgWorld.getPlayersOfMap(map)
-     * @param {string} map Map Name
-     * @returns {Array<RpgPlayer>}
-     * @memberof RpgWorld
-     */
-    getPlayersOfMap(map: string): RpgPlayer[] {
-        const room: any = World.getRoom(map)
-        return Object.values(room.users) as RpgPlayer[]
-    }
-}
-
-export const Query = new QueryClass()

package/src/Scenes/Map.ts

@@ -1,310 +0,0 @@
-
-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'
-import { inject } from '../inject'
-
-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()
-    private server: RpgServerEngine = inject(RpgServerEngine)
-
-    constructor(sceneMapObject: SceneMapObject) {
-        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.
-     * 
-     * @title Get maps
-     * @method sceneMap.getMaps()
-     * @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', {
-            id: 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) {
-            mapInstance.loadCommonEvents(this.server.inputOptions.events, player)
-            player.createDynamicEvent(<any>mapInstance._events, false)
-            await player.execMethod('onJoinMap', <any>[mapInstance])
-        }
-
-        return mapInstance
-    }
-}

package/src/decorators/event.ts

@@ -1,58 +0,0 @@
-import { EventMode } from "../Game/EventManager"
-
-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
-    }
-}