@rpgjs/server 4.3.0 → 5.0.0-alpha.1

package/src/decorators/map.ts

@@ -1,226 +0,0 @@
-import { TiledMap } from '@rpgjs/tiled'
-import { componentSchema, RpgPlayer } from '../Player/Player'
-
-export interface MapOptions {
-    /** 
-     * Map identifier. Allows to go to the map (for example with player.changeMap())
-     * 
-     * @prop {string} [id]
-     * @memberof MapData
-     * */
-    id?: string,
-
-    /** 
-    * the path to the .tmx file (Tiled Map Editor)
-    * 
-    * Remember to use `require()` function
-    * 
-    * ```ts
-    * import { MapData, RpgMap } from '@rpgjs/server'
-    * 
-    * @MapData({
-    *      id: 'town',
-    *      file: require('./tmx/town.tmx')
-    * })
-    * class TownMap extends RpgMap { } 
-    * ``` 
-    * @prop {string} file
-    * @memberof MapData
-    * */
-    file: string | TiledMap,
-
-    /** 
-     * The name of the map.
-     * @prop {string} [name]
-     * @memberof MapData
-     * */
-    name?: string,
-
-    /** 
-    * Map events. This is an array containing `RpgEvent` classes. 
-    * You can also give an object that will indicate the positions of the event on the map.
-    * 
-    * ```ts
-    * import { MapData, RpgMap, EventData, RpgEvent } from '@rpgjs/server'
-    * 
-    * @EventData({
-    *      name: 'Ev-1'
-    * })
-    * class NpcEvent extends RpgEvent { }
-    * 
-    * @MapData({
-    *      id: 'medieval',
-    *      file: require('./tmx/town.tmx'),
-    *      events: [NpcEvent]
-    * })
-    * class TownMap extends RpgMap {}
-    * ```
-    * 
-    * If the positions are not defined, the event will be placed on a Tiled Map Editor shape ([/guide/create-event.html#position-the-event-on-the-map](Guide)). Otherwise, it will be placed at `{x:0, y:0 }`
-    * 
-    * You can give positions:
-    * 
-    * ```ts
-    * events: [{ event: NpcEvent, x: 10, y: 30 }]
-    * ```
-    * 
-    * @prop {Class of RpgEvent[] | { event: Class RpgEvent, x: number, y: number }} [events]
-    * @memberof MapData
-    * */
-    events?: { event: any, x: number, y: number }[] | any[],
-
-    /** 
-     * The sounds that will be played when the map is open. Sounds must be defined on the client side. Then, put the name of the sound identifier
-     * 
-     * So, it is possible to play several sounds (in loop or not) on the card. You can put a background music (BGM) and a background noise (BGS) for example
-     * 
-     *  ```ts
-     * sounds: ['my-bgm', 'my-bgs']
-     * ```
-     * 
-     * And client side:
-     * 
-     * ```ts
-     * import { Sound } from '@rpgjs/client'
-     * 
-     * @Sound({
-     *      sounds: {
-     *          'my-bgm': require('./assets/bgm.ogg'),
-     *          'my-bgs': require('./assets/bgs.ogg')
-     *      },
-     *      loop: true
-     * })
-     * export class Sounds {}
-     * ```
-     * 
-     * See [https://docs.rpgjs.dev/classes/sound.html#properties](RpgSound Decorator)
-     * 
-     * @prop {Array<string>} [sounds]
-     * @memberof MapData
-     * */
-    sounds?: string[]
-
-    /** 
-     * Specify which properties will be synchronized with the client. On the client side, you can retrieve the values synchronized with the valueChanges property on the scene
-     * 
-     * You must create the schema:
-     * 
-     * ```ts
-     * import { MapData, RpgMap } from '@rpgjs/server'
-     * 
-     * @MapData({
-     *      id: 'medieval',
-     *      file: require('./tmx/town.tmx'),
-     *      syncSchema: {
-     *          count: Number
-     *      }
-     * })
-     * export class TownMap extends RpgMap {
-     *      count: number = 0
-     * 
-     *      onLoad() {}
-     * 
-     *      onJoin() {
-     *          this.count++
-     *      }
-     * 
-     *      onLeave(player) {
-     *          super.onLeave(player)
-     *          this.count--
-     *      }
-     * }
-     * 
-     * ```
-     * 
-     * If you want to change the scheme of players and events, consider overwriting the existing scheme
-     * 
-     *  ```ts
-     * import { MapData, RpgMap, RpgPlayer } from '@rpgjs/server'
-     * 
-     * 
-     * declare module '@rpgjs/server' {
-     *  export interface RpgPlayer {
-     *      customProp: string
-     *  }
-     * }
-     * 
-     * @MapData({
-     *      id: 'medieval',
-     *      file: require('./tmx/town.tmx'),
-     *      syncSchema: {
-     *          users: [
-     *              {
-     *                  customProp: String,
-     *                  ...RpgPlayer.schemas
-     *              }
-     *          ]
-     *      }
-     * })
-     * export class TownMap extends RpgMap {}
-     * ```
-     * 
-     * The properties are called `users` and `events`. Their scheme is identical and defined in `RpgPlayer.schemas`. To write schematics, refer to the [documentation of the simple-room](https://github.com/RSamaium/simple-room) module
-     * 
-     * @prop {object} [syncSchema]
-     * @memberof MapData
-     * */
-    syncSchema?: any
-
-    /** 
-     * Decreases the RAM of the map. In this case, some instructions will be different.
-     * 
-     * `map.getTileByIndex()` will not return all tiles of an index but only the tile of the highest layer
-     * 
-     * > You can also use the `low-memory` property in Tiled maps
-     * 
-     * @prop {boolean} [lowMemory=false]
-     * @since 3.1.0
-     * @memberof MapData
-     * */
-    lowMemory?: boolean
-}
-
-export function MapData(options: MapOptions) {
-    return (target) => {
-        target.file = options.file
-        target.id = options.id
-        target.type = 'map'
-        target.prototype.name = options.name
-        target.prototype.file = options.file
-        target.prototype.id = options.id
-        target.prototype.sounds = options.sounds
-        target.prototype.lowMemory = options.lowMemory
-
-        target.prototype.$schema = {}
-
-        if (options.syncSchema) {
-            target.prototype.$schema = options.syncSchema
-        }
-        if (!target.prototype.$schema.shapes) {
-            target.prototype.$schema.shapes = [
-                {
-                    type: String,
-                    name: String,
-                    x: Number,
-                    y: Number,
-                    width: Number,
-                    height: Number,
-                    properties: {
-                        collision: Boolean
-                    },
-                    polygon: [{ x: Number, y: Number }],
-                    rotation: Number,
-                    components: [componentSchema]
-                }
-            ]
-        }
-        if (!target.prototype.$schema.users) {
-            target.prototype.$schema.users = [RpgPlayer.schemas]
-        }
-        if (!target.prototype.$schema.events) {
-            target.prototype.$schema.events = [RpgPlayer.schemas]
-        }
-
-        target.prototype._events = options.events
-    }
-}

package/src/entry-point.ts

@@ -1,111 +0,0 @@
-import { RpgCommonGame, HookServer, loadModules, ModuleType, GameSide, RpgPlugin, InjectContext } from '@rpgjs/common'
-import { RpgServerEngine } from './server'
-import { RpgPlayer } from './Player/Player'
-import { RpgMatchMaker } from './MatchMaker'
-import { inject, setInject } from './inject'
-
-interface RpgServerEntryPointOptions {
-    /** 
-    * Represents socket io but you can put something else (which is of the same scheme as socket io)
-    * 
-    * @prop {SocketIO or other} io
-    * @memberof RpgServerEntryPoint
-    * */
-    io: any,
-    /** 
-     * It allows you to know where the maps are located. Usually put `__dirname` for the current directory.
-     * 
-     * ```ts
-     * basePath: __dirname
-     * ``` 
-     * 
-     * @prop {string} basePath
-     * @memberof RpgServerEntryPoint
-     * */
-    basePath: string
-
-    standalone?: boolean
-
-    /** 
-   * The general configurations of the game.
-   * 
-   * @prop {object} [globalConfig]
-   * @memberof RpgServerEntryPoint
-   * */
-    globalConfig?: any
-
-    workers?: any
-
-    envs?: object
-}
-
-export default async function (modules: ModuleType[], options: RpgServerEntryPointOptions): Promise<RpgServerEngine> {
-    const context = new InjectContext()
-    setInject(context)
-
-    inject(RpgCommonGame, [GameSide.Server])
-
-    if (!options.globalConfig) options.globalConfig = {}
-
-    const relations = {
-        onConnected: HookServer.PlayerConnected,
-        onInput: HookServer.PlayerInput,
-        onJoinMap: HookServer.PlayerJoinMap,
-        onLeaveMap: HookServer.PlayerLeaveMap,
-        onLevelUp: HookServer.PlayerLevelUp,
-        onDead: HookServer.PlayerDead,
-        onDisconnected: HookServer.PlayerDisconnected,
-        onInShape: HookServer.PlayerInShape,
-        onOutShape: HookServer.PlayerOutShape,
-        onMove: HookServer.PlayerMove,
-        canChangeMap: HookServer.PlayerCanChangeMap
-    }
-
-    const relationsEngine = {
-        onStart: HookServer.Start,
-        onStep: HookServer.Step,
-        auth: HookServer.Auth
-    }
-
-    const { playerProps } = await loadModules(modules, {
-        side: 'server',
-        relations: {
-            player: relations,
-            engine: relationsEngine,
-            scalability: {
-                onConnected: HookServer.ScalabilityPlayerConnected,
-                doChangeServer: HookServer.ScalabilityChangeServer
-            }
-        }
-    }, (mod) => {
-        const { scalability } = mod
-        if (scalability) {
-            const { hooks, stateStore, matchMaker } = scalability
-            const matchMakerInstance = new RpgMatchMaker(matchMaker)
-            RpgPlugin.on(HookServer.Start, () => {
-                return stateStore.connect()
-            })
-            mod.scalability._hooks = {}
-            for (let hookName in hooks) {
-                let originalHook = mod.scalability.hooks[hookName]
-                mod.scalability._hooks[hookName] = function (player: RpgPlayer) {
-                    return originalHook(stateStore, matchMakerInstance, player)
-                }
-            }
-        }
-        return mod
-    })
-
-    const serverEngine = inject(RpgServerEngine, [
-        options.io, {
-            debug: {},
-            updateRate: 10,
-            stepRate: 60,
-            timeoutInterval: 0,
-            countConnections: false,
-            playerProps,
-            ...options
-        }
-    ])
-    return serverEngine
-}

package/src/express/api.ts

@@ -1,118 +0,0 @@
-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

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

package/src/express/errors/NotFound.ts

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

package/src/express/server.ts

@@ -1,94 +0,0 @@
-import http from 'http'
-import path from 'path'
-import express from 'express'
-import cors from 'cors'
-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,
-    envs?: {
-        [key: string]: string
-    }
-}
-
-export function expressServer(modules: ModuleType[], options: ExpressServerOptions): Promise<{
-    app: express.Express,
-    server: http.Server,
-    game: RpgServerEngine
-}> {
-    return new Promise((resolve, reject) => {
-        const envs = options.envs || {}
-        const { express: expressConfig = {} } = options.globalConfig || {}
-        const dirname = options.basePath
-        const PORT = process.env.PORT || expressConfig.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"]
-            },
-            ...(expressConfig.socketIo || {})
-        })
-
-        // @ts-ignore
-        const isBuilt = !!envs.VITE_BUILT
-
-        // @ts-ignore
-        const hasStatic = process.env.STATIC_DIRECTORY_ENABLED
-        const staticDirectory = isBuilt ? expressConfig.static ?? '' : 'dist'
-        // @ts-ignore
-        const staticEnabled = (isBuilt && hasStatic === undefined) || hasStatic === 'true'
-
-        app.use(express.json(expressConfig.json))
-        app.use(cors(expressConfig.cors))
-
-        if (staticEnabled || expressConfig.static) {
-            app.use('/', express.static(path.join(dirname, '..', staticDirectory, 'client')))
-        }
-
-        let rpgGame: RpgServerEngine
-
-        async function start() {
-            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 getPort = (url: string) => {
-            const array = url.split(':')
-            return array[array.length - 1]
-        }
-        console.log(envs.VITE_SERVER_URL)
-        const serverPort = !isBuilt ? getPort(envs.VITE_SERVER_URL) || PORT : 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))
-        })
-    })
-}

package/src/inject.ts

@@ -1,33 +0,0 @@
-import { InjectContext } from "@rpgjs/common";
-
-let instanceContext: InjectContext | null = null
-
-/**
- * Dependency injection function for RPGJS server side.
- * 
- * The server-side `inject` function is designed for retrieving instances of server-related classes in the RPGJS framework. 
- * This function is crucial for accessing singleton instances of classes like `RpgServerEngine` on the server. It facilitates 
- * a clean and efficient approach to handling dependencies within server modules, contributing to a more organized codebase.
- *
- * @template T The class type that you want to retrieve an instance of, specific to server-side modules.
- * @returns {T} Returns the singleton instance of the specified class, ensuring consistent server-side behavior and state management.
- * @since 4.2.0
- *
- * @example
- * ```ts
- * // Example of injecting the RpgServerEngine
- * import { inject, RpgServerEngine } from '@rpgjs/server'
- * const server = inject(RpgServerEngine)
- * ```
- */
-export function inject<T>(service: new (...args: any[]) => T, args: any[] = []): T {
-    return instanceContext!.inject(service, args);
-}
-
-export function setInject(context: InjectContext) {
-    instanceContext = context;
-}
-
-export function clearInject() {
-    instanceContext = null
-}

package/src/models/Item.ts

@@ -1,11 +0,0 @@
-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) => {}
-}