@rpgjs/server 4.0.0-rc.9 → 4.0.2

package/src/Player/ItemManager.ts

@@ -1,7 +1,6 @@
 import { Utils } from '@rpgjs/common'
-import { Effect, ItemOptions } from '@rpgjs/database'
+import { Effect, ClassHooks, ItemClass, ItemInstance, WeaponInstance, ArmorInstance, WeaponClass, ArmorClass } from '@rpgjs/database'
 import { ItemLog } from '../logs'
-import { ItemModel } from '../models/Item'
 import { EffectManager } from './EffectManager'
 import { GoldManager } from './GoldManager'
 import { StateManager } from './StateManager'
@@ -18,13 +17,13 @@ const {
     applyMixins
 } = Utils
 
-type ItemClass = { new(...args: any[]), price?: number, _type?: string }
-type Inventory = { nb: number, item: ItemModel }
+
+type Inventory = { nb: number, item: ItemInstance }
 
 export class ItemManager {
 
     items: Inventory[]
-    equipments: ItemModel[] = []
+    equipments: ItemInstance[] = []
 
     /**
     * Retrieves the information of an object: the number and the instance 
@@ -464,7 +463,7 @@ export class ItemManager {
      * }
      * ```
      */
-    equip(itemClass: ItemClass | string, equip: boolean = true): void {
+    equip(itemClass: WeaponClass | ArmorClass | string, equip: boolean = true): void {
         const inventory: Inventory = this.getItem(itemClass)
         if (!inventory) {
             throw ItemLog.notInInventory(itemClass)
@@ -472,7 +471,16 @@ export class ItemManager {
         if ((itemClass as ItemClass)._type == 'item') {
             throw ItemLog.invalidToEquiped(itemClass)
         }
-        const { item } = inventory
+
+        if (this._class && this._class[ClassHooks.canEquip]) {
+            const canEquip = this['execMethodSync'](ClassHooks.canEquip, [inventory.item, this], this._class)
+            if (!canEquip) {
+                throw ItemLog.canNotEquip(itemClass)
+            }
+        }
+
+        const item: WeaponInstance | ArmorInstance = inventory.item as any
+        
         if (item.equipped && equip) {
             throw ItemLog.isAlreadyEquiped(itemClass)
         }

package/src/Player/ParameterManager.ts

@@ -95,7 +95,7 @@ export class ParameterManager {
         if (val > this.param[MAXHP]) {
             val = this.param[MAXHP]
         }
-        else if (val <= 0) { 
+        else if (val <= 0) {
             this['execMethod']('onDead') 
             val = 0
         }

package/src/Player/Player.ts

@@ -46,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,
@@ -74,7 +86,7 @@ const playerSchemas = {
         z: Number
     },
     direction: Number,
-   
+
     teleported: {
         $permanent: false
     },
@@ -90,14 +102,23 @@ const playerSchemas = {
     level: {
         $effects: ['$this.expForNextlevel']
     },
-    expForNextlevel: Number,
+    expForNextlevel: {
+        $permanent: false
+    },
     exp: Number,
     name: String,
     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: {
@@ -168,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
@@ -470,7 +503,9 @@ export class RpgPlayer extends RpgCommonPlayer {
      * @returns {Promise<boolean | RpgMap | null>}
      * @memberof Player
      */
-    load(json: any): Promise<boolean | RpgMap | null> {
+    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))()
@@ -489,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))
@@ -501,12 +538,17 @@ export class RpgPlayer extends RpgCommonPlayer {
         merge(this, json)
 
         this.position = json.position
+
         if (json.map) {
             this.map = ''
-            return this.changeMap(json.map, json.tmpPositions || json.position)
+            const map = await this.changeMap(json.map, json.tmpPositions || json.position)
+            this._dataLoading = false
+            return map
         }
 
-        return Promise.resolve(null)
+        this._dataLoading = false
+
+        return null
     }
 
     /**
@@ -803,7 +845,19 @@ export class RpgPlayer extends RpgCommonPlayer {
         }
     }
 
+    private execMethodSync<T>(methodName: string, methodData = [], target?: any): T {
+        let ret
+        if (target && target[methodName]) {
+            ret = target[methodName](...methodData)
+        }
+        return ret
+    }
+
     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)
@@ -995,4 +1049,4 @@ export class RpgEvent extends RpgPlayer {
             }
         }
     }
-}
+}

package/src/Player/SkillManager.ts

@@ -6,10 +6,6 @@ import { EffectManager } from './EffectManager'
 import { ParameterManager } from './ParameterManager';
 import { RpgPlayer } from './Player';
 
-import { 
-    INT
-} from '../presets'
-
 const { 
     isArray, 
     isString, 
@@ -29,14 +25,14 @@ export class SkillManager {
                 return skill.id == skillClass
             }
             if (isString(skillClass)) {
-                return skillClass == skill.id || skill
+                return skillClass == (skill.id || skill)
             }
             return isInstanceOf(skill, skillClass)
         })
     }
 
     /**
-     * Retrieves a skill. Returns null, if not found
+     * Retrieves a learned skill. Returns null, if not found
      * ```ts
      * import Fire from 'your-database/skills/fire'
      * 
@@ -68,15 +64,23 @@ export class SkillManager {
      * @title Learn Skill
      * @method player.learnSkill(skillClass)
      * @param {SkillClass | string} skillClass or data id
+     * @throws {SkillLog} alreadyLearned
+     *  If the player already knows the skill
+     *  ```
+        {
+            id: SKILL_ALREADY_LEARNED,
+            msg: '...'
+        }
+        ```
      * @returns {instance of SkillClass}
      * @memberof SkillManager
      */
     learnSkill(skillClass: SkillClass | string) {
+        if (this.getSkill(skillClass)) {
+            throw SkillLog.alreadyLearned(skillClass)
+        }
         if (isString(skillClass)) skillClass = this.databaseById(skillClass)
         const instance = new (skillClass as SkillClass)()
-        if (!instance.coefficient) instance.coefficient = {
-            [INT]: 1
-        }
         this.skills.push(instance)
         this['execMethod']('onLearn', [this], instance)
         return instance

package/src/express/server.ts

@@ -23,8 +23,9 @@ export function expressServer(modules: ModuleType[], options: ExpressServerOptio
 }> {
     return new Promise((resolve, reject) => {
         const envs = options.envs || {}
+        const { express: expressConfig = {} } = options.globalConfig || {}
         const dirname = options.basePath
-        const PORT = process.env.PORT || 3000
+        const PORT = process.env.PORT || expressConfig.port || 3000
         const pe = new PrettyError()
         const app = express()
         const server = http.createServer(app)
@@ -33,7 +34,8 @@ export function expressServer(modules: ModuleType[], options: ExpressServerOptio
             cors: {
                 origin: "*",
                 methods: ["GET", "POST"]
-            }
+            },
+            ...(expressConfig.socketIo || {})
         })
 
         // @ts-ignore
@@ -41,20 +43,14 @@ export function expressServer(modules: ModuleType[], options: ExpressServerOptio
 
         // @ts-ignore
         const hasStatic = process.env.STATIC_DIRECTORY_ENABLED
-        const staticDirectory = isBuilt ? '' : 'dist'
+        const staticDirectory = isBuilt ? expressConfig.static ?? '' : 'dist'
         // @ts-ignore
         const staticEnabled = (isBuilt && hasStatic === undefined) || hasStatic === 'true'
 
-        if (!isBuilt) {
-            app.use(express.json({
-                // TODO
-                limit: '50mb'
-            }))
-        }
-
-        app.use(cors())
+        app.use(express.json(expressConfig.json))
+        app.use(cors(expressConfig.cors))
 
-        if (staticEnabled) {
+        if (staticEnabled || expressConfig.static) {
             app.use('/', express.static(path.join(dirname, '..', staticDirectory, 'client')))
         }
 
@@ -77,7 +73,7 @@ export function expressServer(modules: ModuleType[], options: ExpressServerOptio
         }
 
         // @ts-ignore
-        const serverPort = (envs.VITE_SERVER_URL || '').split(':')[1] || PORT
+        const serverPort = !isBuilt ? (envs.VITE_SERVER_URL || '').split(':')[1] || PORT : PORT
         server.listen(serverPort, start)
 
         process.on('uncaughtException', function (error) {

package/src/index.ts

@@ -11,7 +11,7 @@ export {
     ShapePositioning,
     AbstractObject
 } from '@rpgjs/common'
-export { RpgServer, RpgPlayerHooks, RpgServerEngineHooks } from './RpgServer'
+export type { RpgServer, RpgPlayerHooks, RpgServerEngineHooks } from './RpgServer'
 export { EventData } from './decorators/event'
 export { MapData } from './decorators/map'
 export { RpgPlayer, RpgEvent } from './Player/Player'
@@ -23,8 +23,8 @@ export { default as Monitor } from './Monitor'
 export * as Presets from './presets'
 export { Move, Frequency, Speed } from './Player/MoveManager'
 export { RpgServerEngine } from './server'
-export { SceneMap as RpgSceneMap, RpgClassMap } from './Scenes/Map'
+export { SceneMap as RpgSceneMap, type RpgClassMap } from './Scenes/Map'
 export { RpgMatchMaker } from './MatchMaker'
-export { IStoreState } from './Interfaces/StateStore'
+export type { IStoreState } from './Interfaces/StateStore'
 export { Components } from './Player/ComponentManager'
 export { Gui } from './Gui/Gui'

package/src/logs/item.ts

@@ -13,6 +13,9 @@ export class ItemLog {
     static invalidToEquiped(itemClass) {
         return new Log('INVALID_ITEM_TO_EQUIP', `The item ${itemClass.name} is not a weapon or armor`)
     }
+    static canNotEquip(itemClass) {
+        return new Log('CANNOT_EQUIP', `The item ${itemClass.name} cannot be equiped`)
+    }
     static isAlreadyEquiped(itemClass) {
         return new Log('ITEM_ALREADY_EQUIPED', `The item ${itemClass.name} is already equiped`)
     }

package/src/logs/skill.ts

@@ -13,4 +13,7 @@ export class SkillLog {
     static restriction(skillClass) {
         return new Log('RESTRICTION_SKILL', `A state blocks the use of the ${skillClass.name} skill`)
     }
+    static alreadyLearned(skillClass) {
+        return new Log('SKILL_ALREADY_LEARNED', `The ${skillClass.name} skill is already learned`)
+    }
 }

package/src/server.ts

@@ -35,8 +35,6 @@ export class RpgServerEngine {
      * */
     public globalConfig: any = {}
 
-    public assetsPath: string = 'assets'
-
     /**
      * Combat formulas
      * 
@@ -81,7 +79,6 @@ export class RpgServerEngine {
         }
 
         this.globalConfig = this.inputOptions.globalConfig
-        if (this.globalConfig.assetsPath !== undefined) this.assetsPath = this.globalConfig.assetsPath
 
         if (!this.inputOptions.maps) this.inputOptions.maps = []
         if (!this.inputOptions.events) this.inputOptions.events = []
@@ -340,6 +337,10 @@ export class RpgServerEngine {
         return RpgPlugin
     }
 
+    get assetsPath(): string {
+        return this.envs?.['VITE_ASSETS_PATH'] || 'assets'
+    }
+
     sendToPlayer(currentPlayer, eventName, data) {
         currentPlayer._socket.emit(eventName, data)
     }
@@ -351,6 +352,8 @@ export class RpgServerEngine {
         player.session = token
 
         socket.on('move', (data: { input: string[], frame: number }) => {
+            if (!data?.input) return
+            if (!Array.isArray(data.input)) return
             const controlPlayer = player.otherPossessedPlayer ?? player
             if (!controlPlayer.canMove) {
                 return