@rpgjs/server 4.0.0-beta.9 → 4.0.0-rc.10

package/src/Player/MoveManager.ts

@@ -1,7 +1,7 @@
 import { Direction, LiteralDirection, RpgShape, Vector2d } from '@rpgjs/common'
 import { Utils } from '@rpgjs/common'
 import { Behavior, ClientMode, MoveMode, MoveTo, PositionXY, SocketEvents, SocketMethods, Tick } from '@rpgjs/types'
-import { Observable, Subscription, takeUntil, Subject } from 'rxjs'
+import { Observable, Subscription, takeUntil, Subject, tap, switchMap, of, from, debounceTime } from 'rxjs'
 import { RpgServerEngine } from '../server'
 import { RpgEvent, RpgPlayer } from './Player'
 
@@ -444,20 +444,28 @@ export class MoveManager {
             this._finishRoute = resolve
             routes = routes.map((route: any) => {
                 if (isFunction(route)) {
-                    return route(this, this.getCurrentMap())
+                    const map = this.getCurrentMap()
+                    if (!map) {
+                        return undefined
+                    }
+                    return route.apply(route, [this, map])
                 }
                 return route
             })
             routes = arrayFlat(routes)
-            const move = () => {
+            const move = (): Observable<any> => {
                 // If movement continues while the player no longer exists or is no longer on the map
                 if (!this) {
-                    return
+                    return of(null)
+                }
+                // if map not exists
+                if (!this.getCurrentMap()) {
+                    return of(null)
                 }
                 if (count >= this['nbPixelInTile']) {
                     if (frequence < this.frequency) {
                         frequence++
-                        return
+                        return of(null)
                     }
                 }
 
@@ -468,37 +476,49 @@ export class MoveManager {
 
                 if (route === undefined) {
                     this.breakRoutes()
-                    return
+                    return of(null)
                 }
 
+                let ob$ = new Observable()
+
                 switch (route) {
                     case Direction.Left:
                     case Direction.Down:
                     case Direction.Right:
                     case Direction.Up:
-                        this.moveByDirection(route, 1)
+                        ob$ = from(this.moveByDirection(route, 1))
                         break
                     case 'turn-' + Direction.Left:
-                        this.changeDirection(Direction.Left)
+                        ob$ = of(this.changeDirection(Direction.Left))
                         break
                     case 'turn-' + Direction.Right:
-                        this.changeDirection(Direction.Right)
+                        ob$ = of(this.changeDirection(Direction.Right))
                         break
                     case 'turn-' + Direction.Up:
-                        this.changeDirection(Direction.Up)
+                        ob$ = of(this.changeDirection(Direction.Up))
                         break
                     case 'turn-' + Direction.Down:
-                        this.changeDirection(Direction.Down)
+                        ob$ = of(this.changeDirection(Direction.Down))
                         break
                 }
 
-                routes.shift()
+                return ob$.pipe(
+                    tap(() => {
+                        routes.shift()
+                    })
+                )
             }
             this.movingSubscription = this.server.tick
                 .pipe(
-                    takeUntil(this._destroy$)
+                    takeUntil(
+                        this._destroy$.pipe(
+                            tap(() => {
+                                this.breakRoutes(true)
+                            })
+                        )),
+                    switchMap(move)
                 )
-                .subscribe(move)
+                .subscribe()
         })
     }
 
@@ -550,7 +570,7 @@ export class MoveManager {
      */
     breakRoutes(force: boolean = false): void {
         if (this._finishRoute) {
-            this.movingSubscription.unsubscribe()
+            this.movingSubscription?.unsubscribe()
             this._finishRoute(force)
         }
     }

package/src/Player/ParameterManager.ts

@@ -1,6 +1,4 @@
 import { Utils } from '@rpgjs/common'
-import { RpgPlayer } from './Player'
-
 import { 
     MAXHP, 
     MAXSP,
@@ -97,8 +95,8 @@ export class ParameterManager {
         if (val > this.param[MAXHP]) {
             val = this.param[MAXHP]
         }
-        else if (val <= 0) { 
-            this['_triggerHook']('onDead')
+        else if (val <= 0) {
+            this['execMethod']('onDead') 
             val = 0
         }
         this._hp = val
@@ -187,7 +185,7 @@ export class ParameterManager {
      * */
     set level(val: number) {
         const lastLevel = this._level
-        if (this.finalLevel && this._level > this.finalLevel) {
+        if (this.finalLevel && val > this.finalLevel) {
             val = this.finalLevel
         }
         if (this._class) {
@@ -200,7 +198,9 @@ export class ParameterManager {
             }
         }
         const hasNewLevel = val - lastLevel
-        if (hasNewLevel > 0) this['_triggerHook']('onLevelUp', hasNewLevel)
+        if (hasNewLevel > 0) {
+            this['execMethod']('onLevelUp', <any>[hasNewLevel])   
+        }
         this._level = val
     }
 
@@ -342,6 +342,7 @@ export class ParameterManager {
         }
     }) {
         this._paramsModifier = val
+        this.changeRoomState('param')
     }
 
     get parameters() {
@@ -370,7 +371,7 @@ export class ParameterManager {
         return features
     }
 
-    getParamValue(name: string): number {
+    getParamValue(name: string): number | never {
         const features = this.getParam(name)
         let curveVal = Math.floor((features.end - features.start) * ((this.level-1) / (this.finalLevel - this.initialLevel))) + features.start
         const modifier = this.paramsModifier[name]
@@ -410,6 +411,15 @@ export class ParameterManager {
             start,
             end
         })
+        const maxHp = this.param[MAXHP]
+        const maxSp = this.param[MAXSP]
+        if (name == MAXHP && this.hp > maxHp) {
+            this.hp = maxHp // forcing hp not to exceed maxp 
+        }
+        else if (name == MAXSP && this.sp > maxSp) {
+            this.sp = maxSp
+        }
+        this.changeRoomState('param.' + name)
     }
 
     /** 
@@ -464,5 +474,6 @@ export class ParameterManager {
 
 export interface ParameterManager {
     _class,
-    $schema
+    $schema,
+    changeRoomState(key: string): void
 }

package/src/Player/Player.ts

@@ -1,5 +1,5 @@
 import { RpgCommonPlayer, Utils, RpgPlugin, RpgCommonGame, RpgCommonMap, Direction } from '@rpgjs/common'
-import { Room } from 'simple-room'
+import { Room, WorldClass } from 'simple-room'
 import { RpgMap, EventPosOption } from '../Game/Map'
 import { Query } from '../Query'
 import merge from 'lodash.merge'
@@ -36,6 +36,7 @@ import { RpgTiledWorldMap } from '../Game/WorldMaps'
 import { CameraOptions, PositionXY_OptionalZ, SocketEvents, SocketMethods, LayoutObject } from '@rpgjs/types'
 import { ComponentManager } from './ComponentManager'
 import { Subject } from 'rxjs'
+import { EventManager, EventMode } from '../Game/EventManager'
 
 const {
     isPromise,
@@ -45,14 +46,26 @@ const {
 
 export interface Position { x: number, y: number, z: number }
 
-const itemSchemas = {
-    name: String,
-    description: String,
-    price: Number,
-    consumable: Boolean,
+const commonSchemaFeature = {
+    name: {
+        $permanent: false
+    },
+    description: {
+        $permanent: false
+    },
     id: String
 }
 
+const itemSchemas = {
+    price: {
+        $permanent: false
+    },
+    consumable: {
+        $permanent: false
+    },
+    ...commonSchemaFeature
+}
+
 export const componentSchema = { id: String, value: String }
 export const layoutSchema = {
     width: Number,
@@ -73,22 +86,39 @@ const playerSchemas = {
         z: Number
     },
     direction: Number,
+
     teleported: {
         $permanent: false
     },
+
+    deleted: {
+        $permanent: false
+    },
+
     param: Object,
     hp: Number,
     sp: Number,
     gold: Number,
-    level: Number,
+    level: {
+        $effects: ['$this.expForNextlevel']
+    },
+    expForNextlevel: {
+        $permanent: false
+    },
     exp: Number,
     name: String,
-    expForNextlevel: Number,
     items: [{ nb: Number, item: itemSchemas }],
-    _class: { name: String, description: String, id: String },
+    _class: commonSchemaFeature,
     equipments: [itemSchemas],
-    skills: [{ name: String, description: String, spCost: Number, id: String }],
-    states: [{ name: String, description: String, id: String }],
+    skills: [
+        {
+            spCost: {
+                $permanent: false
+            },
+            ...commonSchemaFeature
+        }
+    ],
+    states: [commonSchemaFeature],
     effects: [String],
 
     layout: {
@@ -159,14 +189,26 @@ export class RpgPlayer extends RpgCommonPlayer {
     public _rooms = []
     public session: string | null = null
     public prevMap: string = ''
-    /** @internal */
+
+    /** 
+    * ```ts
+    * retreive the server instance
+    * ``` 
+    * @title Server Instance
+    * @prop {RpgServerEngine} player.server
+    * @memberof Player
+    * */
     public server: RpgServerEngine
     private touchSide: boolean = false
+
     /** @internal */
     public tmpPositions: Position | string | null = null
     public otherPossessedPlayer: RpgPlayer | RpgEvent | null = null
     public following: RpgPlayer | RpgEvent | null = null
 
+    // Indicates whether to load data with load(). In this case, hooks are not triggered.
+    private _dataLoading: boolean = false
+
     _lastFramePositions: {
         frame: number
         position: Position
@@ -182,9 +224,16 @@ export class RpgPlayer extends RpgCommonPlayer {
         return super.otherPlayersCollision as RpgPlayer[]
     }
 
+    get world(): WorldClass | undefined {
+        return this.server?.world
+    }
+
     // As soon as a teleport has been made, the value is changed to force the client to change the positions on the map without making a move.
     teleported: number = 0
 
+    // a flag that lets the client know if the event is suppressed. The client can, for example, end animations before completely deleting the object (client side).
+    deleted: boolean = false
+
     /** @internal */
     initialize() {
         this.expCurve = {
@@ -391,6 +440,7 @@ export class RpgPlayer extends RpgCommonPlayer {
         let ret = {}
         for (let key in events) {
             this.events[key] = events[key]
+            this.events[key].playerRelated = this
             this.events[key].execMethod('onInit', [this])
             // force to get Proxy object to sync with client
             ret = { ...ret, [key]: this.events[key] }
@@ -398,21 +448,6 @@ export class RpgPlayer extends RpgCommonPlayer {
         return ret
     }
 
-    /**
-     * Removes an event from the map (Scenario Mode). Returns false if the event is not found
-     * @title Remove Event
-     * @since 3.0.0-beta.4
-     * @method player.removeEvent(eventId)
-     * @param {string} eventId Event Name
-     * @returns {boolean}
-     * @memberof Player
-     */
-    removeEvent(eventId: string): boolean {
-        if (!this.events[eventId]) return false
-        delete this.events[eventId]
-        return true
-    }
-
     /**
      * Allows to change the positions of the player on the current map. 
      * You can put the X and Y positions or the name of the created shape on Tiled Map Editor.
@@ -465,10 +500,12 @@ export class RpgPlayer extends RpgCommonPlayer {
      * @title Load progress
      * @method player.load(json)
      * @param {string} json The JSON sent by the method save()
-     * @returns {string}
+     * @returns {Promise<boolean | RpgMap | null>}
      * @memberof Player
      */
-    load(json: any) {
+    async load(json: any): Promise<boolean | RpgMap | null> {
+        this._dataLoading = true
+
         if (isString(json)) json = JSON.parse(json)
 
         const getData = (id) => new (this.databaseById(id))()
@@ -487,10 +524,12 @@ export class RpgPlayer extends RpgCommonPlayer {
                 items[it.item.id] = getData(it.item.id)
             }
             json.items = json.items.map(it => ({ nb: it.nb, item: items[it.item.id] }))
-            json.equipments = json.equipments.map(it => {
-                items[it.id].equipped = true
-                return items[it.id]
-            })
+            if (Array.isArray(json.equipments)) {
+                json.equipments = json.equipments.map(it => {
+                    items[it.id].equipped = true
+                    return items[it.id]
+                })
+            }
         }
         if (json.states) json.states = json.states.map(state => getData(state.id))
         if (json.skills) json.skills = json.skills.map(skill => getData(skill.id))
@@ -499,10 +538,17 @@ export class RpgPlayer extends RpgCommonPlayer {
         merge(this, json)
 
         this.position = json.position
+
         if (json.map) {
             this.map = ''
-            this.changeMap(json.map, json.tmpPositions || json.position)
+            const map = await this.changeMap(json.map, json.tmpPositions || json.position)
+            this._dataLoading = false
+            return map
         }
+
+        this._dataLoading = false
+
+        return null
     }
 
     /**
@@ -659,6 +705,7 @@ export class RpgPlayer extends RpgCommonPlayer {
      * This is useful, if for example, you want to make an animated character (sword stroke when pressing a key)
      * When the animation is finished, the original graphic is displayed again
      * 
+     * 
      * ```ts
      * player.showAnimation('sword_stroke', 'default', true)
      * ```
@@ -669,6 +716,10 @@ export class RpgPlayer extends RpgCommonPlayer {
      * player.showAnimation(['body', 'sword_stroke'], 'default', true)
      * ```
      * 
+     * ::: tip
+     * For this to work, the animations must have been previously defined in `setGraphic`.
+     * :::
+     * 
      * @title Show Animation
      * @method player.showAnimation(graphic,animationName,replaceGraphic=false)
      * @param {string | string[]} graphic spritesheet identifier
@@ -679,7 +730,6 @@ export class RpgPlayer extends RpgCommonPlayer {
      */
     showAnimation(graphic: string | string[], animationName: string, replaceGraphic: boolean = false) {
         this.emitToMap('callMethod', {
-            objectId: this.playerId,
             name: SocketMethods.ShowAnimation,
             params: [graphic, animationName, replaceGraphic]
         })
@@ -784,12 +834,30 @@ export class RpgPlayer extends RpgCommonPlayer {
         if (this._socket) this._socket.removeAllListeners(key)
     }
 
+    disconnect() {
+        if (this._socket) this._socket.disconnect()
+    }
+
     emitToMap(key: string, value: any) {
-        Query.getPlayersOfMap(this.map).forEach(player => player.emit(key, value))
+        const map = this.getCurrentMap()
+        if (map) {
+            map.$setCurrentState(`users.${this.id}.${key}`, value)
+        }
     }
 
-    async execMethod(methodName: string, methodData = []) {
-        const ret = await RpgPlugin.emit(`Server.${methodName}`, [this, ...methodData], true)
+    async execMethod(methodName: string, methodData = [], target?: any) {
+        const ignoreIfDataLoading = ['onLevelUp', 'onDead']
+        if (ignoreIfDataLoading.includes(methodName) && this._dataLoading) {
+            return
+        }
+        let ret
+        if (target && target[methodName]) {
+            ret = target[methodName](...methodData)
+            if (isPromise(ret)) await ret
+        }
+        else {
+            ret = await RpgPlugin.emit(`Server.${methodName}`, [this, ...methodData], true)
+        }
         this.syncChanges()
         return ret
     }
@@ -799,6 +867,21 @@ export class RpgPlayer extends RpgCommonPlayer {
         this.emit('Player.' + name, val)
     }
 
+    // @internal
+    /**
+     * Allows you to manually update a status in the rooms that will then be sent to the customer.
+     * @param path 
+     * @example
+     * ```ts
+     * player.changeRoomState('hp')
+     * ```
+     */
+    changeRoomState(path: string) {
+        this.world?.forEachUserRooms(this.id, (room) => {
+            (room as any).$setCurrentState(`users.${this.id}.${path}`)
+        })
+    }
+
     private _eventChanges() {
         if (!this._getMap(this.map)) return
         const {
@@ -839,18 +922,18 @@ export class RpgPlayer extends RpgCommonPlayer {
      * @title Play Sound
      * @method player.playSound(soundId,allMap=false)
      * @param {string} soundId Sound identifier, defined on the client side
-     * @param {boolean} [allMap] Indicate if the sound is heard by the players on the map
+     * @param {boolean} [forEveryone=false] Indicate if the sound is heard by the players on the map
      * @since 3.0.0-alpha.9
      * @returns {void}
      * @memberof Player
      */
-    playSound(soundId: string, allMap: boolean = false) {
+    playSound(soundId: string, forEveryone: boolean = false) {
         const obj = {
             objectId: this.playerId,
             name: SocketMethods.PlaySound,
             params: [soundId]
         }
-        if (!allMap) {
+        if (!forEveryone) {
             this.emit(SocketEvents.CallMethod, obj)
             return
         }
@@ -860,6 +943,7 @@ export class RpgPlayer extends RpgCommonPlayer {
 }
 
 export interface RpgPlayer extends
+    EventManager,
     ItemManager,
     GoldManager,
     StateManager,
@@ -879,6 +963,7 @@ export interface RpgPlayer extends
 }
 
 applyMixins(RpgPlayer, [
+    EventManager,
     ItemManager,
     GoldManager,
     StateManager,
@@ -894,11 +979,6 @@ applyMixins(RpgPlayer, [
     ComponentManager
 ])
 
-export enum EventMode {
-    Shared = 'shared',
-    Scenario = 'scenario'
-}
-
 export interface RpgClassEvent<T> {
     _name: string
     new(): T,
@@ -908,24 +988,57 @@ export class RpgEvent extends RpgPlayer {
 
     public readonly type: string = 'event'
     properties: any = {}
+    mode: EventMode
+    playerRelated: RpgPlayer | null = null
+
+    constructor(gameEngine: RpgCommonGame, playerId: string) {
+        super(gameEngine, playerId)
+    }
 
     async execMethod(methodName: string, methodData = []) {
         if (!this[methodName]) {
             return
         }
         const ret = this[methodName](...methodData)
-        const sync = () => {
-            const player: any = methodData[0]
-            if (player instanceof RpgPlayer) {
-                player.syncChanges()
-            }
+        return ret
+    }
+
+    changeRoomState(path: string) {
+        const room = this.getCurrentMap()
+        if (room) {
+            (room as any).$setCurrentState(`events.${this.id}.${path}`)
         }
-        if (Utils.isPromise(ret)) {
-            ret.then(sync)
+    }
+
+    /**
+    * Deletes the event from the map (in shared or scenario mode)
+    * 
+    * @title Remove
+    * @since 4.0.0
+    * @method event.remove()
+    * @returns {boolean} true if the event has been removed. If false, the event is not on the map
+    * @memberof RpgEvent
+    */
+    remove(): boolean {
+        let bool = false
+        if (this.playerRelated) bool = this.playerRelated.removeEvent(this.id)
+        const map = this.getCurrentMap()
+        if (map) {
+            bool = map.removeEvent(this.id)
         }
-        else {
-            sync()
+        return bool
+    }
+
+    override emitToMap(key: string, value: any) {
+        const map = this.getCurrentMap()
+        if (map) {
+            const eventPath = `events.${this.id}.${key}`
+            if (this.playerRelated) {
+                map.$setCurrentState(`users.${this.playerRelated.id}.${eventPath}`, value)
+            }
+            else {
+                map.$setCurrentState(eventPath, value)
+            }
         }
-        return ret
     }
-}
+}