@rpgjs/server 3.3.2 → 4.0.0-beta.3

package/src/express/api.ts

@@ -0,0 +1,118 @@
+import { Router } from 'express'
+import { RpgServerEngine } from '../server'
+import { Query } from '../Query'
+import { RpgMap } from '../Game/Map'
+import { NotAuthorized } from './errors/NotAuthorized'
+import { NotFound } from './errors/NotFound'
+
+type ApiConfig = {
+    enabled?: boolean,
+    authSecret?: string,
+}
+
+export function api(rpgServer: RpgServerEngine): Router {
+    const router = new Router()
+
+    router.use((req, res, next) => {
+        try {
+            const apiConfig: ApiConfig = rpgServer.globalConfig.api || {}
+            const enabled = apiConfig.enabled === undefined ? false : apiConfig.enabled
+            const { dev } = req.query
+            if (process.env.NODE_ENV === 'development' && dev) {
+                return next()
+            }
+            if (!enabled) {
+                throw new NotAuthorized('API disabled')
+            }
+            const authSecret = apiConfig.authSecret
+            if (!authSecret) {
+                throw new NotAuthorized('API secret not defined')
+            }
+            // headers
+            const authHeader = req.headers.authorization
+            if (!authHeader) {
+                throw new NotAuthorized('Authorization header not defined')
+            }
+            const [type, token] = authHeader.split(' ')
+            if (type !== 'Bearer') {
+                throw new NotAuthorized('Authorization type not supported')
+            }
+            if (token !== authSecret) {
+                throw new NotAuthorized('Authorization token not valid')
+            }
+            next()
+        }
+        catch (err) {
+            next(err)
+        }
+    })
+
+    router.get('/players', (req, res) => {
+        const players = Query.getPlayers()
+        res.json(players)
+    })
+
+    router.put('/maps', (req, res, next) => {
+        try {
+            const { mapId, data, mapFile } = req.body
+            const maps = rpgServer.sceneMap.getMaps()
+            const findMap = maps.find(map => {
+                if (mapId) {
+                    return map.id === mapId
+                }
+                else if (mapFile) {
+                    return map.file === mapFile
+                }
+            })
+            if (findMap) {
+                const map = Query.getRoom<RpgMap>(findMap.id as string)
+                map.update(data)
+                res.json({ success: true })
+            }
+            else {
+                throw new NotFound('Map not found')
+            }
+        }
+        catch (err) {
+            next(err)
+        }
+    })
+
+    router.put('/tilesets', async (req, res, next) => {
+        try {
+            const { data, tilesetId } = req.body
+            const maps = Query.getRooms<RpgMap>()
+            for (let [id, map] of maps) {
+                const findTileset = map.tilesets.find(tileset => tileset.name === tilesetId)
+                if (findTileset) {
+                    await map.updateTileset(data)
+                }
+            }
+            res.json({ success: true })
+        }
+        catch (err) {
+            next(err)
+        }
+    })
+
+    router.put('/worlds', (req, res, next) => {
+        try {
+            const { worldId, data } = req.body
+            const sceneMap = rpgServer.sceneMap
+            const world = sceneMap.getWorldMaps(worldId)
+            if (world) {
+                sceneMap.deleteWorldMaps(worldId)
+                sceneMap.createDynamicWorldMaps(data)
+                res.json({ success: true })
+            }
+            else {
+                throw new NotFound('World not found')
+            }
+        }
+        catch (err) {
+            next(err)
+        }
+    })
+
+    return router
+}

package/src/express/errors/NotAuthorized.ts

@@ -0,0 +1,6 @@
+export class NotAuthorized extends Error {
+    status = 401
+    constructor(message?: string) {
+        super(message || 'Not authorized')
+    }
+}

package/src/express/errors/NotFound.ts

@@ -0,0 +1,6 @@
+export class NotFound extends Error {
+    status = 404
+    constructor(message?: string) {
+        super(message || 'Not found')
+    }
+}

package/src/express/server.ts

@@ -0,0 +1,93 @@
+import http from 'http'
+import path from 'path'
+import express from 'express'
+import { Server } from 'socket.io'
+import entryPoint from '../entry-point'
+import PrettyError from 'pretty-error'
+import { ModuleType } from '@rpgjs/common'
+import { RpgServerEngine } from '../server'
+import { api } from './api'
+import { Query } from '../Query'
+
+type ExpressServerOptions = {
+    basePath: string,
+    globalConfig?: any,
+}
+
+export function expressServer(modules: ModuleType[], options: ExpressServerOptions): Promise<{
+    app: express.Express,
+    server: http.Server,
+    game: RpgServerEngine
+}> {
+    return new Promise((resolve, reject) => {
+        const dirname = options.basePath
+        const PORT = process.env.PORT || 3000
+        const pe = new PrettyError()
+        const app = express()
+        const server = http.createServer(app)
+        const io = new Server(server, {
+            maxHttpBufferSize: 1e10,
+            cors: {
+                origin: "*",
+                methods: ["GET", "POST"]
+            }
+        })
+
+        // @ts-ignore
+        const isBuilt = !!import.meta.env.VITE_BUILT
+        
+        // @ts-ignore
+        const hasStatic = process.env.STATIC_DIRECTORY_ENABLED
+        const staticDirectory = isBuilt ? '' : 'dist'
+        // @ts-ignore
+        const staticEnabled = (isBuilt && hasStatic === undefined) || hasStatic === 'true'
+
+        if (!isBuilt) {
+            app.use(express.json({
+                // TODO
+                limit: '50mb'
+            }))
+        }
+       
+        if (staticEnabled) {
+            app.use('/', express.static(path.join(dirname, '..', staticDirectory, 'client')))
+        }
+
+        async function start() {
+            const rpgGame = await entryPoint(modules, { io, ...options })
+            rpgGame.app = app
+            rpgGame.start()
+            app.use('/api', api(rpgGame))
+            app.use((err: any, req: any, res: any, next: any) => {
+                const status = err.status || 500
+                res.status(status).json({ error: err.message })
+            })
+            resolve({
+                app,
+                server,
+                game: rpgGame
+            })
+        }
+
+        // @ts-ignore
+        const serverPort = (import.meta.env.VITE_SERVER_URL || '').split(':')[1] || PORT
+        server.listen(serverPort, start)
+
+        process.on('uncaughtException', function (error) {
+            console.log(pe.render(error))
+        })
+
+        process.on('unhandledRejection', function (reason: any) {
+            console.log(pe.render(reason))
+        })
+
+        if (import.meta['hot']) {
+            import.meta['hot'].on("vite:beforeFullReload", () => {
+                server.close()
+                Query.getPlayers().forEach(player => {
+                    player.gameReload()
+                })
+            });
+        }
+    })
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+export { default as entryPoint } from './entry-point'
+export { 
+    Direction, 
+    Input, 
+    Control, 
+    RpgPlugin, 
+    HookServer, 
+    HookClient, 
+    RpgModule,
+    RpgShape,
+    ShapePositioning,
+    AbstractObject
+} from '@rpgjs/common'
+export { RpgServer, RpgPlayerHooks, RpgServerEngineHooks } from './RpgServer'
+export { EventData } from './decorators/event'
+export { MapData } from './decorators/map'
+export { RpgPlayer, RpgEvent, EventMode } from './Player/Player'
+export { RpgMap } from './Game/Map'
+export { RpgWorldMaps } from './Game/WorldMaps'
+export { Query, Query as RpgWorld } from './Query'
+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 { RpgMatchMaker } from './MatchMaker'
+export { IStoreState } from './Interfaces/StateStore'
+export { Components } from './Player/ComponentManager'

package/src/logs/index.ts

@@ -0,0 +1,11 @@
+import { ItemLog } from './item'
+import { SkillLog } from './skill'
+import { StateLog } from './state'
+import { Log } from './log'
+
+export {
+    ItemLog,
+    SkillLog,
+    StateLog,
+    Log
+}

package/src/logs/item.ts

@@ -0,0 +1,31 @@
+import { Log } from './log'
+
+export class ItemLog {
+    static notInInventory(itemClass) {
+        return new Log('ITEM_NOT_INVENTORY', `The item ${itemClass.name} is not in inventory`)
+    }
+    static notUseItem(itemClass) {
+        return new Log('NOT_USE_ITEM', `The player cannot use the ${itemClass.name} item.`)
+    }
+    static chanceToUseFailed(itemClass) {
+        return new Log('USE_CHANCE_ITEM_FAILED', `Chance to use the ${itemClass.name} item has failed`)
+    }
+    static invalidToEquiped(itemClass) {
+        return new Log('INVALID_ITEM_TO_EQUIP', `The item ${itemClass.name} is not a weapon or armor`)
+    }
+    static isAlreadyEquiped(itemClass) {
+        return new Log('ITEM_ALREADY_EQUIPED', `The item ${itemClass.name} is already equiped`)
+    }
+    static haveNotPrice(itemClass) {
+        return new Log('NOT_PRICE', `Define a price > 0 to buy ${itemClass.name}`)
+    }
+    static notEnoughGold(itemClass, nb) {
+        return new Log('NOT_ENOUGH_GOLD', `not enough gold to buy ${nb} ${itemClass.name}`)
+    }
+    static tooManyToSell(itemClass, nbToSell, nb) {
+        return new Log('TOO_MANY_ITEM_TO_SELL', `Too many items to sell: ${nbToSell} ${itemClass.name}, only ${nb} in inventory`)
+    }
+    static restriction(itemClass) {
+        return new Log('RESTRICTION_ITEM', `A state blocks the use of the ${itemClass.name} skill`)
+    }
+}

package/src/logs/log.ts

@@ -0,0 +1,3 @@
+export class Log {
+    constructor(private id: string, private msg: string) {}
+}

package/src/logs/skill.ts

@@ -0,0 +1,16 @@
+import { Log } from './log'
+
+export class SkillLog {
+    static notLearned(skillClass) {
+        return new Log('SKILL_NOT_LEARNED', `the skill ${skillClass.name} is not learned`)
+    }
+    static notEnoughSp(skillClass, skillSp, playerSp) {
+        return new Log('NOT_ENOUGH_SP', `not enough SP to use ${skillClass.name} skill. ${skillSp} Skill'SP is is greater than ${playerSp} Player'SP`)
+    }
+    static chanceToUseFailed(skillClass) {
+        return new Log('USE_CHANCE_SKILL_FAILED', `Chance to use the ${skillClass.name} skill has failed`)
+    }
+    static restriction(skillClass) {
+        return new Log('RESTRICTION_SKILL', `A state blocks the use of the ${skillClass.name} skill`)
+    }
+}

package/src/logs/state.ts

@@ -0,0 +1,13 @@
+import { Log } from './log'
+
+export class StateLog {
+    static addFailed(stateClass) {
+        return new Log('ADD_STATE_FAILED', `Adding the ${stateClass.name} state has failed`)
+    }
+    static removeFailed(stateClass) {
+        return new Log('REMOVE_STATE_FAILED', `Removing the ${stateClass.name} state has failed`)
+    }
+    static notApplied(stateClass) {
+        return new Log('STATE_NOT_APPLIED', `State ${stateClass.name} does not exist`)
+    }
+}

package/src/models/Item.ts

@@ -0,0 +1,11 @@
+import { ItemOptions } from '@rpgjs/database'
+import { RpgPlayer } from '../Player/Player';
+
+export interface ItemModel extends ItemOptions {
+    id: string
+    equipped?: boolean
+    onUseFailed?: (player: RpgPlayer) => {}
+    onUse?: (player: RpgPlayer) => {}
+    onAdd?: (player: RpgPlayer) => {}
+    onRemove?: (player: RpgPlayer) => {}
+}

package/src/presets/index.ts

@@ -0,0 +1,71 @@
+import { Utils } from '@rpgjs/common'
+
+const { random } = Utils
+
+export const MAXHP: string = 'maxHp'
+export const MAXSP: string = 'maxSp'
+export const ATK: string = 'atk'
+export const PDEF: string = 'pdef'
+export const SDEF: string = 'sdef'
+export const STR: string = 'str'
+export const AGI: string = 'agi'
+export const INT: string = 'int'
+export const DEX: string = 'dex'
+
+export const MAXHP_CURVE = {
+    start: 741,
+    end: 7467
+}
+export const MAXSP_CURVE = {
+    start: 534,
+    end: 5500
+}
+export const STR_CURVE = {
+    start: 67,
+    end: 635
+}
+export const AGI_CURVE = {
+    start: 58,
+    end: 582
+}
+export const INT_CURVE = {
+    start: 36,
+    end: 7318
+}
+export const DEX_CURVE = {
+    start: 54,
+    end: 564
+}
+
+export const DAMAGE_CRITICAL = function(damage, a, b) {
+    if (random(0, 100) < 4 * a[DEX] / b[AGI]) {
+        damage *= 2
+    }
+    return damage
+}
+
+export const DAMAGE_PHYSIC = function(a, b) {
+    let damage = Math.round((a[ATK] - b[PDEF] / 2) * ((20 + a[STR]) / 20))
+    if (damage < 0) damage = 0
+    return damage
+}
+
+export const DAMAGE_GUARD = function(damage) {
+    return damage / 2
+}
+
+export const COEFFICIENT_ELEMENTS = function(a, b, bDef) {
+    return ((a.rate + 1) * (b.rate + 1)) / (bDef.rate == 0 ? bDef.rate * 4 : 1)
+}
+
+export const DAMAGE_SKILL = function(a, b, skill) {
+    let power = skill.power + (a[ATK] * (skill.coefficient[ATK] || 0))
+    if (power > 0) {
+        power -= b[PDEF] * (skill.coefficient[PDEF] || 0) / 2
+        power -= b[SDEF] * (skill.coefficient[SDEF] || 0) / 2
+        power = Math.max(power, 0)
+    }
+    let rate = 20;
+    [STR, DEX, AGI, INT].forEach(val => rate += a[val] * (skill.coefficient[val] || 0))
+    return Math.round(power * rate / 20)
+}