@rpgjs/server 3.3.2 → 4.0.0-beta.3

package/src/Gui/ShopGui.ts

@@ -0,0 +1,43 @@
+import { PrebuiltGui } from '@rpgjs/common'
+import { Gui } from './Gui'
+import { RpgPlayer } from '../Player/Player'
+import { IGui } from '../Interfaces/Gui'
+
+export class ShopGui extends Gui implements IGui {
+    constructor(player: RpgPlayer) {
+        super(PrebuiltGui.Shop, player)
+    }
+
+    open(items: any[]) {
+        items = items.map(item => {
+            const it = new item()
+            return {
+                price: it.price,
+                name: it.name,
+                description: it.description,
+                id: it.id,
+                type: item.type
+            }
+        })
+        this.on('buyItem', ({ id, nb }) => {
+            try {
+                this.player.buyItem(id, nb)
+            }
+            catch (err) {
+                console.log(err)
+            }
+        })
+        this.on('sellItem', ({ id, nb }) => {
+            try {
+                this.player.sellItem(id, nb)
+            }
+            catch (err) {
+                console.log(err)
+            }
+        })
+        return super.open({ items }, {
+            waitingAction: true,
+            blockPlayerInput: true
+        })
+    }
+}

package/src/Gui/index.ts

@@ -0,0 +1,13 @@
+import { Gui } from './Gui'
+import { DialogGui } from './DialogGui'
+import { MenuGui } from './MenuGui'
+import { ShopGui } from './ShopGui'
+import { NotificationGui } from './NotificationGui'
+
+export { 
+    Gui,
+    DialogGui,
+    MenuGui,
+    ShopGui,
+    NotificationGui
+}

package/src/Interfaces/Gui.ts

@@ -0,0 +1,4 @@
+export interface IGui {
+    open(...any): Promise<any>
+    close?()
+}

package/src/Interfaces/StateStore.ts

@@ -0,0 +1,5 @@
+export interface IStoreState {
+    connect(): Promise<any>
+    get(key: string): Promise<string | null>
+    set(key: string, val: string): Promise<any>
+}

package/src/MatchMaker.ts

@@ -0,0 +1,63 @@
+
+import axios from 'axios'
+import { Utils } from '@rpgjs/common'
+import { RpgPlayer } from './Player/Player'
+
+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 = player.server.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

@@ -0,0 +1,78 @@
+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/Player/BattleManager.ts

@@ -0,0 +1,123 @@
+import { Utils }  from '@rpgjs/common'
+import { ParameterManager } from './ParameterManager'
+import { RpgPlayer } from './Player'
+import { 
+    ATK,
+    PDEF,
+    SDEF
+} from '../presets'
+import { Effect } from '@rpgjs/database'
+import { ElementManager } from './ElementManager';
+import { EffectManager } from './EffectManager';
+import { RpgServerEngine } from '../server'
+
+const { 
+    applyMixins
+} = Utils
+
+export class BattleManager {
+
+    /** 
+     * Apply damage. Player will lose HP. the `otherPlayer` 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 }
+     * ```
+     * 
+     * @title Apply Damage
+     * @method player.applyDamage(otherPlayer,skill)
+     * @param {RpgPlayer} otherPlayer The attacking player
+     * @param {any} [skill]
+     * @returns {object} 
+     * @memberof BattleManager
+     * */
+    applyDamage(otherPlayer: RpgPlayer, skill?: any): { 
+        damage: number, 
+        critical: boolean, 
+        elementVulnerable: boolean,
+        guard: boolean,
+        superGuard: boolean
+    } {
+        const getParam = (player) => {
+            const params = {}
+            this.parameters.forEach((val, key) => {
+                params[key] = player.param[key]
+            })
+            return {
+                [ATK]: player.atk,
+                [PDEF]: player.pdef,
+                [SDEF]: player.sdef,
+                ...params
+            }
+        }
+        let damage = 0, fn
+        let critical = false
+        let guard = false
+        let superGuard = false
+        let elementVulnerable = false
+        const paramA = getParam(otherPlayer)
+        const paramB = getParam(this)
+        if (skill) {
+            fn = this.getFormulas('damageSkill')
+            if (!fn) {
+                throw new Error('Skill Formulas not exists')
+            }
+            damage = fn(paramA, paramB, skill)
+        }
+        else {
+            fn = this.getFormulas('damagePhysic')
+            if (!fn) {
+                throw new Error('Physic Formulas not exists')
+            }
+            damage = fn(paramA, paramB)
+            const coef = this.coefficientElements(otherPlayer)
+            if (coef >= 2) {
+                elementVulnerable = true
+            }
+            damage *= coef
+            fn = this.getFormulas('damageCritical')
+            if (fn) {
+                let newDamage = fn(damage, paramA, paramB)
+                if (damage != newDamage) {
+                    critical = true
+                }
+                damage = newDamage
+            }
+        }
+        if (this.hasEffect(Effect.GUARD)) {
+            fn = this.getFormulas('damageGuard')
+            if (fn) {
+                let newDamage = fn(damage, paramA, paramB)
+                if (damage != newDamage) {
+                    guard = true
+                }
+                damage = newDamage
+            }
+        }
+        if (this.hasEffect(Effect.SUPER_GUARD)) {
+            damage /= 4
+        }
+        this.hp -= damage
+        return {
+            damage,
+            critical,
+            elementVulnerable,
+            guard,
+            superGuard
+        }
+    }
+    
+    getFormulas(name: string) {
+        return this.server.damageFormulas[name]
+    }
+}
+
+applyMixins(BattleManager, [ParameterManager, ElementManager, EffectManager])
+
+export interface BattleManager extends ParameterManager, ElementManager, EffectManager {
+    name: string,
+    server: RpgServerEngine
+ }

package/src/Player/ClassManager.ts

@@ -0,0 +1,72 @@
+import { Utils }  from '@rpgjs/common'
+import { ParameterManager } from './ParameterManager'
+import { ItemManager } from './ItemManager'
+
+const { 
+    applyMixins
+} = Utils
+
+export class ClassManager {
+
+    _class: any
+
+    /** 
+     * Assign a class to the player
+     * 
+     * ```ts
+     * import { Fighter } from 'my-database/classes/fighter'
+     * 
+     * player.setClass(Fighter)
+     * ```
+     * 
+     * @title Set Class
+     * @method player.setClass(ClassClass)
+     * @param {ClassClass} class
+     * @returns {instance of ClassClass} 
+     * @memberof ClassManager
+     * */
+    setClass(_class) {
+        this._class = new _class()
+        this['execMethod']('onSet', [this], this._class)
+        return this._class
+    }
+
+    /** 
+     * Allows to give a set of already defined properties to the player (default equipment, or a list of skills to learn according to the level)
+     * 
+     * ```ts
+     * import { Hero } from 'my-database/classes/hero'
+     * 
+     * player.setActor(Hero)
+     * ```
+     * 
+     * @title Set Actor
+     * @method player.setActor(ActorClass)
+     * @param {ActorClass} actorClass
+     * @returns {instance of ActorClass} 
+     * @memberof ClassManager
+     * */
+    setActor(actorClass) {
+        const actor = new actorClass()
+        this.name  = actor.name
+        this.initialLevel = actor.initialLevel
+        this.finalLevel = actor.finalLevel
+        this.expCurve = actor.expCurve
+        for (let param in actor.parameters) {
+            this.addParameter(param, actor.parameters[param])
+        }
+        for (let item of actor.startingEquipment) {
+            this.addItem(item)
+            this.equip(item, true)
+        }
+        this.setClass(actor.class)
+        this['execMethod']('onSet', [this], actor)
+        return actor
+    }
+}
+
+applyMixins(ClassManager, [ParameterManager, ItemManager])
+
+export interface ClassManager extends ParameterManager, ItemManager {
+    name: string
+ }