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

package/src/Game/EventManager.ts

@@ -0,0 +1,110 @@
+import { PlayerType } from "@rpgjs/types"
+import { RpgEvent, RpgPlayer } from "../Player/Player"
+import { RpgMap } from "./Map"
+
+export type EventsList = {
+    [playerId: string]: RpgEvent
+}
+
+export enum EventMode {
+    Shared = 'shared',
+    Scenario = 'scenario'
+}
+
+/**
+ *  ⚠️ Please note that the event system can be on the player or on the card.
+ * On player, it's Scenario mode
+ * On-map: Shared mode
+ * So this here is either RpgMap or RpgPlayer
+ * You can check the mode with the mode cleanup on the retrieved event
+ */
+export class EventManager {
+    /** 
+   * @title event list
+   * @prop { { [eventId: string]: RpgEvent } } [events]
+   * @memberof Map
+   * */
+    public events: EventsList
+
+    /**
+    * Get Event in current map
+    * @title Get Event
+    * @since 3.0.0-beta.7
+    * @method map.getEvent(eventId)
+    * @param {string} eventId Event Id
+    * @returns {RpgEvent | undefined}
+    * @memberof Map
+    */
+    getEvent<T extends RpgEvent>(eventId: string): T | undefined {
+        return this.events[eventId] as T
+    }
+
+    getEventByName<T extends RpgEvent>(eventName: string): T | undefined {
+        const events = Object.keys(this.events)
+        const key = events.find(key => this.events[key].name == eventName)
+        if (!key) return
+        return this.events[key] as T
+    }
+
+    /**
+    * Removes an event from the map. Returns false if the event is not found
+    * 
+    * Deletion of an event forced to be performed at the end of several aynschronous notions
+    * 
+    * @title Remove Event
+    * @since 3.0.0-beta.4
+    * @method map.removeEvent(eventId)
+    * @param {string} eventId Event Name
+    * @returns {boolean}
+    * @memberof Map
+    */
+    removeEvent(eventId: string): boolean {
+        if (!this.events[eventId]) return false
+        const mode = this.events[eventId].mode
+        this.removeObject(this.events[eventId], mode)
+        delete this.events[eventId]
+        // Change the state of the packet that will be sent to the client, adding the deleted flag to indicate to the client that the event has been deleted.
+        if (mode == EventMode.Scenario) {
+            this.getCurrentMap()?.$setCurrentState(`users.${this.id}.events.${eventId}.deleted`, true)
+        }
+        else {
+            this.$setCurrentState(`events.${eventId}.deleted`, true)
+        }
+        return true
+    }
+
+    // @internal
+    removeObject(object: RpgPlayer | RpgEvent, mode: EventMode = EventMode.Shared) {
+        const map = this.getCurrentMap()
+        if (!map) return
+        map.getShapes().forEach(shape => shape.out(object))
+        const events: RpgPlayer[] = Object.values(map.game.world.getObjectsOfGroup(map.id, object))
+        for (let event of events) {
+            object.getShapes().forEach(shape => shape.out(event))
+            event.getShapes().forEach(shape => shape.out(object))
+        }
+        object._destroy$.next()
+        object._destroy$.complete()
+        // force RXJS, close subject. TODO: avoid this
+        if (object.type != PlayerType.Player) object._destroy$['_closed'] = true
+        map.grid.clearObjectInCells(object.id)
+        for (let playerId in map.players) {
+            if (object.id == playerId) continue
+            const otherPlayer = map.players[playerId]
+            if (otherPlayer.following?.id == object.id) {
+                otherPlayer.cameraFollow(otherPlayer)
+            }
+        }
+        // last player before removed of this map 
+        if (map.nbPlayers === 1 && object.type === PlayerType.Player) {
+            // clear cache for this map
+            map.remove(true)
+        }
+    }
+}
+
+export interface EventManager {
+    getCurrentMap(): RpgMap | null
+    id: string
+    $setCurrentState: (path: string, value: any) => void;
+}

package/src/Game/Map.ts

@@ -1,13 +1,14 @@
 import { RpgCommonMap, Utils, RpgShape, RpgCommonGame, AbstractObject } from '@rpgjs/common'
 import { TiledParserFile, TiledParser, TiledTileset } from '@rpgjs/tiled'
 import { EventOptions } from '../decorators/event'
-import { RpgPlayer, EventMode, RpgEvent, RpgClassEvent } from '../Player/Player'
+import { RpgPlayer, RpgEvent, RpgClassEvent } from '../Player/Player'
 import { Move } from '../Player/MoveManager'
 import { RpgServerEngine } from '../server'
 import { Observable } from 'rxjs'
 import path from 'path'
-import { HitBox, MovingHitbox, Position } from '@rpgjs/types'
+import { HitBox, MovingHitbox, PlayerType, Position } from '@rpgjs/types'
 import { World } from 'simple-room'
+import { EventManager, EventMode } from './EventManager'
 
 export type EventPosOption = {
     x: number,
@@ -63,15 +64,9 @@ export class RpgMap extends RpgCommonMap {
     public _events: EventOption[]
     public file: any
 
-    /** 
-    * @title event list
-    * @prop { { [eventId: string]: RpgEvent } } [events]
-    * @memberof Map
-    * */
-    public events: EventsList = {}
-
     constructor(private _server: RpgServerEngine) {
         super()
+        this.events = {}
     }
 
     // alias of users property in simple-room package
@@ -237,7 +232,16 @@ export class RpgMap extends RpgCommonMap {
         this.removeObject(player)
     }
 
-    private loadCommonEvents(commonEvents: RpgClassEvent<RpgEvent>[]) {
+    /**
+     * Loads common events onto the game map.
+     *
+     * @private
+     * @param {RpgClassEvent<RpgEvent>[]} commonEvents - An array of common events to load.
+     * @param {RpgPlayer} [player] - The player instance on which to create the dynamic events. If not provided, the function will use the current instance.
+     * @returns {void}
+     */
+    // @internal
+    loadCommonEvents(commonEvents: RpgClassEvent<RpgEvent>[], player?: RpgPlayer) {
         let events: EventPosOption[] = []
         this.getShapes().forEach(shape => {
             const findEvent = commonEvents.find(event => event._name == shape.name)
@@ -248,8 +252,14 @@ export class RpgMap extends RpgCommonMap {
                 y,
                 event: findEvent
             })
-        })
-        this.createDynamicEvent(events)
+        });
+        if (player) {
+            player.createDynamicEvent(events, false)
+        }
+        else {
+            this.createDynamicEvent(events)
+        }
+
     }
 
     // TODO
@@ -350,7 +360,7 @@ export class RpgMap extends RpgCommonMap {
         const events = this.createEvents(eventsList as EventPosOption[], EventMode.Shared)
         let ret = {}
         for (let key in events) {
-            this.events[key] = events[key]
+            this.events[key] = events[key] as any
             this.events[key].updateInVirtualGrid()
             this.events[key].execMethod('onInit')
             // force to get Proxy object to sync with client
@@ -359,35 +369,6 @@ export class RpgMap extends RpgCommonMap {
         return ret
     }
 
-    /**
-     * Get Event in current map
-     * @title Get Event
-     * @since 3.0.0-beta.7
-     * @method map.getEvent(eventId)
-     * @param {string} eventId Event Id
-     * @returns {RpgEvent | undefined}
-     * @memberof Map
-     */
-    getEvent<T extends RpgEvent>(eventId: string): T | undefined {
-        return this.events[eventId] as T
-    }
-
-    /**
-     * Removes an event from the map. Returns false if the event is not found
-     * @title Remove Event
-     * @since 3.0.0-beta.4
-     * @method map.removeEvent(eventId)
-     * @param {string} eventId Event Name
-     * @returns {boolean}
-     * @memberof Map
-     */
-    removeEvent(eventId: string): boolean {
-        if (!this.events[eventId]) return false
-        this.removeObject(this.events[eventId])
-        delete this.events[eventId]
-        return true
-    }
-
     createEvent(obj: EventPosOption, mode: EventMode, shape?: RpgShape): RpgEvent | null {
         let event: any, position: Position | undefined
 
@@ -397,7 +378,7 @@ export class RpgMap extends RpgCommonMap {
         }
         else {
             event = obj.event
-            position = { x: obj.x, y: obj.y, z: 0 }
+            position = { x: obj.x, y: obj.y, z: obj.z ?? 0 }
         }
 
         // The event is ignored if the mode is different.
@@ -433,30 +414,6 @@ export class RpgMap extends RpgCommonMap {
         return events
     }
 
-    private removeObject(object: RpgPlayer | RpgEvent) {
-        this.getShapes().forEach(shape => shape.out(object))
-        const events: RpgPlayer[] = Object.values(this.game.world.getObjectsOfGroup(this.id, object))
-        for (let event of events) {
-            object.getShapes().forEach(shape => shape.out(event))
-            event.getShapes().forEach(shape => shape.out(object))
-        }
-        object._destroy$.next()
-        object._destroy$.complete()
-        this.grid.clearObjectInCells(object.id)
-        for (let playerId in this.players) {
-            if (object.id == playerId) continue
-            const otherPlayer = this.players[playerId]
-            if (otherPlayer.following?.id == object.id) {
-                otherPlayer.cameraFollow(otherPlayer)
-            }
-        }
-        // last player before removed of this map 
-        if (this.nbPlayers === 1 && object.type === 'player') {
-            // clear cache for this map
-            this.remove(true)
-        }
-    }
-
     /**
      * Allows to create a temporary hitbox on the map that can have a movement
 For example, you can use it to explode a bomb and find all the affected players, or during a sword strike, you can create a moving hitbox and find the affected players again
@@ -501,13 +458,24 @@ For example, you can use it to explode a bomb and find all the affected players,
     setSync(schema: any) {
         return this.$setSchema(schema)
     }
+
+    // Reflects itself. Just for compatibility with the EventManager class
+    getCurrentMap() {
+        return this
+    }
 }
 
-export interface RpgMap {
+export interface RpgMap extends EventManager {
     sounds: string[]
     $schema: any
     $setSchema: (schema: any) => void
     $patchSchema: (schema: any) => void
     $snapshotUser: (userId: string) => any
     onLoad()
-}
+    $setCurrentState: (path: string, value: any) => void;
+    id: string
+}
+
+Utils.applyMixins(RpgMap, [
+    EventManager
+])

package/src/Gui/MenuGui.ts

@@ -11,11 +11,11 @@ export class MenuGui extends Gui implements IGui {
     open() {
         this.on('useItem', (id) => {
             try {
-               // this.player.useItem(id)
+                this.player.useItem(id)
                 this.player.syncChanges()
             }
-            catch (err) {
-                console.log(err)
+            catch (err: any) {
+                this.player.showNotification(err.msg)
             }
         })
         return super.open('', {

package/src/Player/BattleManager.ts

@@ -18,30 +18,30 @@ const {
 export class BattleManager {
 
     /** 
-     * Apply damage. Player will lose HP. the `otherPlayer` parameter is the other player, the one who attacks.
+     * Apply damage. Player will lose HP. the `attackerPlayer` parameter is the other player, the one who attacks.
      * 
      * If you don't set the skill parameter, it will be a physical attack.
      * The attack formula is already defined but you can customize it in the server options
      * 
      * ```ts
-     * player.applyDamage(otherPlayer) // returns { damage: number }
+     * player.applyDamage(attackerPlayer) // returns { damage: number }
      * ```
      * 
      * @title Apply Damage
-     * @method player.applyDamage(otherPlayer,skill)
-     * @param {RpgPlayer} otherPlayer The attacking player
+     * @method player.applyDamage(attackerPlayer,skill)
+     * @param {RpgPlayer} attackerPlayer The attacking player
      * @param {any} [skill]
      * @returns {object} 
      * @memberof BattleManager
      * */
-    applyDamage(otherPlayer: RpgPlayer, skill?: any): { 
+    applyDamage(attackerPlayer: RpgPlayer, skill?: any): { 
         damage: number, 
         critical: boolean, 
         elementVulnerable: boolean,
         guard: boolean,
         superGuard: boolean
     } {
-        const getParam = (player) => {
+        const getParam = (player: RpgPlayer) => {
             const params = {}
             this.parameters.forEach((val, key) => {
                 params[key] = player.param[key]
@@ -58,8 +58,8 @@ export class BattleManager {
         let guard = false
         let superGuard = false
         let elementVulnerable = false
-        const paramA = getParam(otherPlayer)
-        const paramB = getParam(this)
+        const paramA = getParam(attackerPlayer)
+        const paramB = getParam(<any>this)
         if (skill) {
             fn = this.getFormulas('damageSkill')
             if (!fn) {
@@ -73,7 +73,7 @@ export class BattleManager {
                 throw new Error('Physic Formulas not exists')
             }
             damage = fn(paramA, paramB)
-            const coef = this.coefficientElements(otherPlayer)
+            const coef = this.coefficientElements(attackerPlayer)
             if (coef >= 2) {
                 elementVulnerable = true
             }
@@ -99,6 +99,7 @@ export class BattleManager {
         }
         if (this.hasEffect(Effect.SUPER_GUARD)) {
             damage /= 4
+            superGuard = true
         }
         this.hp -= damage
         return {

package/src/Player/ClassManager.ts

@@ -3,9 +3,13 @@ import { ParameterManager } from './ParameterManager'
 import { ItemManager } from './ItemManager'
 
 const { 
-    applyMixins
+    applyMixins,
+    isString
 } = Utils
 
+type ClassClass = { new(...args: any[]) }
+type ActorClass = { new(...args: any[]) }
+
 export class ClassManager {
 
     _class: any
@@ -21,12 +25,13 @@ export class ClassManager {
      * 
      * @title Set Class
      * @method player.setClass(ClassClass)
-     * @param {ClassClass} class
+     * @param {ClassClass} class class or id
      * @returns {instance of ClassClass} 
      * @memberof ClassManager
      * */
-    setClass(_class) {
-        this._class = new _class()
+    setClass(_class: ClassClass | string) {
+        if (isString(_class)) _class = this.databaseById(_class)
+        this._class = new (_class as ClassClass)()
         this['execMethod']('onSet', [this], this._class)
         return this._class
     }
@@ -42,12 +47,13 @@ export class ClassManager {
      * 
      * @title Set Actor
      * @method player.setActor(ActorClass)
-     * @param {ActorClass} actorClass
+     * @param {ActorClass} actorClass actor class or id
      * @returns {instance of ActorClass} 
      * @memberof ClassManager
      * */
-    setActor(actorClass) {
-        const actor = new actorClass()
+    setActor(actorClass: ActorClass | string) {
+        if (isString(actorClass)) actorClass = this.databaseById(actorClass)
+        const actor = new (actorClass as ActorClass)()
         this.name  = actor.name
         this.initialLevel = actor.initialLevel
         this.finalLevel = actor.finalLevel

package/src/Player/EffectManager.ts

@@ -4,6 +4,7 @@ import { ParameterManager } from './ParameterManager'
 
 import {
     MAXHP, 
+    MAXSP
 } from '../presets'
 
 const { 
@@ -22,19 +23,19 @@ export class EffectManager {
             this.hp += item.hpValue
         }
         if (item.hpRate) {
-            this.hp += this.param[MAXHP] / item.hpRate
+            this.hp += this.param[MAXHP] * item.hpRate
         }
         if (item.spValue) {
-            this.sp += item.hpValue
+            this.sp += item.spValue
         }
         if (item.spRate) {
-            this.sp += this.param[MAXHP] / item.hpRate
+            this.sp += this.param[MAXSP] * item.spRate
         }
     }
 
     /** 
      * ```ts
-     * import { Effect } from '@rpgjs/server'
+     * import { Effect } from '@rpgjs/database'
      * 
      * const bool = player.hasEffect(Effect.CAN_NOT_SKILL)
      * ```
@@ -75,7 +76,7 @@ export class EffectManager {
      * Assigns effects to the player. If you give a array, it does not change the effects of the player's states and armor/weapons equipped.
      * 
      * ```ts
-     * import { Effect } from '@rpgjs/server'
+     * import { Effect } from '@rpgjs/database'
      * 
      * player.effects = [Effect.CAN_NOT_SKILL]
      * ``` 

package/src/Player/ElementManager.ts

@@ -101,7 +101,10 @@ export class ElementManager extends ItemFixture {
      * @readonly
      * @memberof ElementManager
      * */
-    get elements() {
+    get elements(): {
+        rate: number,
+        element: string
+    }[] {
         let elements: any = []
         for (let item of this.equipments) {
             if (item.elements) {

package/src/Player/ItemManager.ts

@@ -1,4 +1,4 @@
-import { Utils }  from '@rpgjs/common'
+import { Utils } from '@rpgjs/common'
 import { Effect, ItemOptions } from '@rpgjs/database'
 import { ItemLog } from '../logs'
 import { ItemModel } from '../models/Item'
@@ -6,43 +6,43 @@ import { EffectManager } from './EffectManager'
 import { GoldManager } from './GoldManager'
 import { StateManager } from './StateManager'
 
-import { 
+import {
     ATK,
     PDEF,
     SDEF
 } from '../presets'
 
-const { 
-    isString, 
+const {
+    isString,
     isInstanceOf,
     applyMixins
 } = Utils
 
 type ItemClass = { new(...args: any[]), price?: number, _type?: string }
-type Inventory =  { nb: number, item: ItemModel }
+type Inventory = { nb: number, item: ItemModel }
 
 export class ItemManager {
 
     items: Inventory[]
     equipments: ItemModel[] = []
-    
-     /**
-     * Retrieves the information of an object: the number and the instance 
-     * @title Get Item
-     * @method player.getItem(itemClass)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @memberof ItemManager
-     * @example
-     * 
-     * ```ts
-     * import Potion from 'your-database/potion'
-     * 
-     * player.addItem(Potion, 5)
-     * const inventory = player.getItem(Potion)
-     * console.log(inventory) // { nb: 5, item: <instance of Potion> }
-     *  ```
-     */
+
+    /**
+    * Retrieves the information of an object: the number and the instance 
+    * @title Get Item
+    * @method player.getItem(itemClass)
+    * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
+    * @returns {{ nb: number, item: instance of ItemClass }}
+    * @memberof ItemManager
+    * @example
+    * 
+    * ```ts
+    * import Potion from 'your-database/potion'
+    * 
+    * player.addItem(Potion, 5)
+    * const inventory = player.getItem(Potion)
+    * console.log(inventory) // { nb: 5, item: <instance of Potion> }
+    *  ```
+    */
     getItem(itemClass: ItemClass | string): Inventory {
         const index: number = this._getItemIndex(itemClass)
         return this.items[index]
@@ -281,9 +281,9 @@ export class ItemManager {
         this.gold += (ItemClass.price / 2) * nbToSell
         this.removeItem(ItemClass, nbToSell)
         return inventory
-    } 
+    }
 
-    private getParamItem(name) {
+    private getParamItem(name: string): number {
         let nb = 0
         for (let item of this.equipments) {
             nb += item[name] || 0
@@ -296,14 +296,35 @@ export class ItemManager {
         return nb
     }
 
+    /**
+     * recover the attack sum of items equipped on the player.
+     * 
+     * @title Get the player's attack
+     * @prop {number} player.atk
+     * @memberof ItemManager
+     */
     get atk(): number {
         return this.getParamItem(ATK)
     }
 
+    /**
+    * recover the physic defense sum of items equipped on the player.
+    * 
+    * @title Get the player's pdef
+    * @prop {number} player.pdef
+    * @memberof ItemManager
+    */
     get pdef(): number {
         return this.getParamItem(PDEF)
     }
 
+    /**
+    * recover the skill defense sum of items equipped on the player.
+    * 
+    * @title Get the player's sdef
+    * @prop {number} player.sdef
+    * @memberof ItemManager
+    */
     get sdef(): number {
         return this.getParamItem(SDEF)
     }
@@ -381,7 +402,7 @@ export class ItemManager {
         if (item.consumable === false) {
             throw ItemLog.notUseItem(itemClass)
         }
-        const hitRate = item.hitRate || 1
+        const hitRate = item.hitRate ?? 1
         if (Math.random() > hitRate) {
             this.removeItem(itemClass)
             this['execMethod']('onUseFailed', [this], item)