@rpgjs/common 4.3.0 → 5.0.0-alpha.0

package/src/Map.ts

@@ -1,335 +0,0 @@
-import { HitObject } from './Hit'
-import SAT from 'sat'
-import Utils, { random, intersection, generateUID, isString } from './Utils'
-import { RpgShape } from './Shape'
-import { Hit } from './Hit'
-import { VirtualGrid } from './VirtualGrid'
-import { RpgCommonWorldMaps } from './WorldMaps'
-import { TiledLayer, TiledLayerType, TiledMap, Layer, Tileset, Tile, TiledObject, TiledObjectClass, MapClass } from '@rpgjs/tiled'
-import { Vector2d } from './Vector2d'
-import { AbstractObject } from './AbstractObject'
-import { RpgCommonGame } from './Game'
-import { Observable, map, Subject, takeUntil, mergeMap, from, filter } from 'rxjs'
-import { HitBox, MovingHitbox, Tick } from '@rpgjs/types'
-
-const buffer = new Map()
-const bufferClient = new Map()
-
-export interface TileInfo {
-    tiles: Tile[]
-    hasCollision: boolean | undefined
-    isClimbable?: boolean | undefined
-    isOverlay: boolean | undefined
-    objectGroups: TiledObjectClass[],
-    tileIndex: number
-}
-
-export interface LayerInfo {
-    type: string,
-    name: string,
-    opacity: number,
-    visible: boolean,
-    properties: any,
-    objects: HitObject[]
-    tiles: Tile[]
-}
-
-
-export class RpgCommonMap extends MapClass {
-    /** 
-     * @title map id
-     * @readonly
-     * @prop {string} [id]
-     * @memberof Map
-     * */
-     readonly id: string
-
-    grid: VirtualGrid
-    gridShapes: VirtualGrid
-    gridTiles: VirtualGrid
-
-    get tileWidth() {
-        return this.tilewidth
-    }
-
-    get tileHeight() {
-        return this.tileheight
-    }
-    
-    /** 
-     * @title Layers of map
-     * @prop {object[]} [layers]
-     * @readonly
-     * @memberof Map
-     * @memberof RpgSceneMap
-     * */
-    
-    /** @internal */
-    shapes: {
-        [shapeName: string]: RpgShape
-    } = {}
-
-    private worldMapParent: RpgCommonWorldMaps | undefined
-
-    /** 
-     * Retrieves the X position of the map in the world (0 if no world assigned)
-     * 
-     * @title World X Position
-     * @prop {number} [worldX]
-     * @readonly
-     * @since 3.0.0-beta.8
-     * @memberof Map
-     * */
-    get worldX() {
-        return this.getInWorldMaps()?.getMapInfo(this.id)?.x || 0
-    }
-
-    /** 
-     * Retrieves the Y position of the map in the world (0 if no world assigned)
-     * 
-     * @title World Y Position
-     * @prop {number} [worldY]
-     * @readonly
-     * @since 3.0.0-beta.8
-     * @memberof Map
-     * */
-    get worldY() {
-        return this.getInWorldMaps()?.getMapInfo(this.id)?.y || 0
-    }
-
-    /**
-     * Memorize the maps so you don't have to make a new request or open a file each time you load a map
-     */
-    static get buffer() {
-        return buffer
-    }
-
-    /**
-     * In RPG mode, to avoid confusion with buffer, we have a new variable to memorize the maps
-     */
-    static get bufferClient() {
-        return bufferClient
-    }
-
-    load(data: TiledMap) {
-        super.load(data)
-        this.gridTiles = new VirtualGrid(this.width, this.tileWidth, this.tileHeight)
-        this.grid = new VirtualGrid(this.width, this.tileWidth, this.tileHeight).zoom(10)
-        this.gridShapes = new VirtualGrid(this.width, this.tileWidth, this.tileHeight).zoom(20)
-    }
-
-    /**
-     * Create a shape dynamically on the map
-     * 
-     * Object:
-     *  - (number) x: Position X
-     *  - (number) y: Position Y
-     *  - (number) width: Width
-     *  - (number) height: Height
-     *  - (object) properties (optionnal): 
-     *      - (number) z: Position Z
-     *      - (hexadecimal) color: Color (shared with client)
-     *      - (boolean) collision
-     *      - You can your own properties
-     * 
-     * @title Create Shape
-     * @since 3.0.0-beta.3
-     * @method map.createShape(obj)
-     * @param {object} obj
-     * @returns {RpgShape}
-     * @memberof Map
-     */
-    createShape(obj: HitObject): RpgShape {
-        const id = obj.name = (obj.name || generateUID()) as string
-        const shape = new RpgShape(obj as TiledObjectClass)
-        this.shapes[id] = shape
-        if (!shape.isShapePosition()) {
-            this.gridShapes.insertInCells(id, shape.getSizeBox(this.tileWidth))
-        }
-        // trick to sync with client
-        return this.shapes[id]
-    }
-
-    /**
-     * Delete a shape
-     * 
-     * @title Delete Shape
-     * @method map.removeShape(name)
-     * @param {string} name Name of shape
-     * @returns {void}
-     * @memberof Map
-     */
-    removeShape(name: string) {
-        // TODO: out players after delete shape
-        //this.shapes = this.shapes.filter(shape => shape.name != name)
-        delete this.shapes[name]
-    }
-
-    clearShapes() {
-        this.shapes = {}
-    }
-
-    /**
-     * Return all shapes on the map
-     * 
-     * @title Get Shapes
-     * @method map.getShapes()
-     * @returns {RpgShape[]}
-     * @memberof Map
-     * @memberof RpgSceneMap
-     */
-    getShapes(): RpgShape[] {
-        return Object.values(this.shapes)
-    }
-
-    /**
-     * Returns a shape by its name. Returns undefined is nothing is found
-     * 
-     * @title Get Shape by name
-     * @method map.getShape(name)
-     * @param {string} name Name of shape
-     * @returns {RpgShape[] | undefined}
-     * @memberof Map
-     * @memberof RpgSceneMap
-     */
-    getShape(name: string): RpgShape | undefined {
-        return this.getShapes().find(shape => shape.name == name)
-    }
-    
-    getPositionByShape(filter: (shape: RpgShape) => {}): { x: number, y: number, z: number } | null {
-        const startsFind = this.getShapes().filter(filter)
-        if (startsFind.length) {
-            const start = startsFind[random(0, startsFind.length-1)]
-            return { x: start.hitbox.x, y: start.hitbox.y, z: start.properties.z * this.zTileHeight || 0 }
-        }
-        return null
-    }
-
-    /**
-     * Get tile and verify collision with hitbox
-     * @param hitbox 
-     * @param x 
-     * @param y 
-     * @param z 
-     * @returns TileInfo
-     */
-    getTile(hitbox, x: number, y: number, z: [number, number] = [0, 0]): TileInfo {
-        const tile = {...this.getTileByPosition(x, y, z)}
-        const tilePos = this.getTileOriginPosition(x, y)
-        if (tile.objectGroups) {        
-            for (let object of tile.objectGroups) {
-                const hit = Hit.getHitbox(object, {
-                    x: tilePos.x,
-                    y: tilePos.y
-                })
-                if (hit.type) {
-                    const collided = Hit.testPolyCollision(hit.type, hit.hitbox, hitbox)
-                    if (collided) {
-                        tile.hasCollision = true
-                    }
-                }
-            }
-        }
-        return tile
-    }
-
-    /**
-     * Assign the map to a world
-
-     * @title Assign the map to a world
-     * @method map.setInWorldMaps(name)
-     * @param {RpgWorldMaps} worldMap world maps
-     * @since 3.0.0-beta.8
-     * @memberof Map
-     */
-    setInWorldMaps(worldMap: RpgCommonWorldMaps) {
-        this.worldMapParent = worldMap
-    }
-
-    /**
-     * Remove this map from the world
-     * @title Remove this map from the world
-     * @method map.removeFromWorldMaps()
-     * @returns {boolean | undefined}
-     * @since 3.0.0-beta.8
-     * @memberof Map
-     */
-    removeFromWorldMaps(): boolean | undefined {
-        return this.worldMapParent?.removeMap(this.id)
-    }
-
-     /**
-     * Recover the world attached to this map (`undefined` if no world attached)
-
-     * @title Get attached World
-     * @method map.getInWorldMaps()
-     * @return {RpgCommonWorldMaps | undefined}
-     * @since 3.0.0-beta.8
-     * @memberof Map
-     */
-    getInWorldMaps(): RpgCommonWorldMaps | undefined {
-        return this.worldMapParent
-    }
-
-    boundingMap(nextPosition: Vector2d, hitbox: SAT): { bounding: boolean, nextPosition: Vector2d } | null {
-        let bounding = false
-        if (nextPosition.x < 0) {
-            nextPosition.x = 0
-            bounding = true
-        }
-        else if (nextPosition.y < 0) {
-            nextPosition.y = 0
-            bounding = true
-        }
-        else if (nextPosition.x > this.widthPx - hitbox.w) {
-            nextPosition.x = this.widthPx - hitbox.w
-            bounding = true
-        }
-        else if (nextPosition.y > this.heightPx - hitbox.h) {
-            nextPosition.y = this.heightPx - hitbox.h
-            bounding = true
-        }
-        return {
-            bounding,
-            nextPosition
-        }
-    }
-
-    _createMovingHitbox<T extends RpgCommonGame>(
-        gameEngine: T,
-        tick$: Observable<Tick>,
-        mapId: string,
-        hitboxes: Pick<HitBox, 'width' | 'height' | 'x' | 'y'>[],
-        options: MovingHitbox = {}
-    ): Observable<AbstractObject> {
-        const object = new AbstractObject(gameEngine, Utils.generateUID())
-        object.disableVirtualGrid = true
-        object.map = mapId
-        object.speed = options.speed ?? 1
-        let i = 0
-        let frame = 0
-        const destroyHitbox$ = new Subject<AbstractObject>()
-        return tick$.pipe(
-            takeUntil(destroyHitbox$),
-            filter(() => {
-                frame++
-                return frame % object.speed == 0
-            }),
-            map(() => {
-                const hitbox = hitboxes[i]
-                if (!hitbox) {
-                    destroyHitbox$.next(object)
-                    destroyHitbox$.complete()
-                    return object
-                }
-                object.position.x = hitbox.x
-                object.position.y = hitbox.y
-                object.setHitbox(hitbox.width, hitbox.height)
-                i++
-                return object
-            }),
-            mergeMap((object) => from(object.isCollided(object.position, { allSearch: true }))),
-            map(() => object)
-        )
-    }
-}

package/src/Module.ts

@@ -1,144 +0,0 @@
-import { RpgPlugin, HookServer, HookClient } from './Plugin'
-import { isArray, isClass, isFunction, isPromise } from './Utils'
-import { warning } from './Logger'
-
-enum Side {
-    Server = 'server',
-    Client = 'client'
-}
-
-type ModuleSide = {
-    client?: any,
-    server?: any
-}
-
-export type ModuleType = ModuleSide | [ModuleSide, {
-    client?: any,
-    server?: any
-}]
-
-export function RpgModule<T>(options: T) {
-    return (target) => {
-        if ((options as any).hooks) {
-            target.hooks = (options as any).hooks
-        }
-        for (let key in options) {
-            target.prototype[key] = options[key]
-        }
-    }
-}
-
-export async function loadModules(modules, obj, middleware?: Function): Promise<{ playerProps: any }> {
-    const { side, relations } = obj
-    let playerProps = {}
-    let hooks = {}
-
-    const getModuleClass = (module) => {
-        if (!module) return null
-        let plug: any = []
-        if (!isArray(module)) {
-            plug = [module]
-        }
-        else {
-            plug = module
-        }
-        const [moduleClassSides, options] = plug
-        const moduleClass = moduleClassSides[side]
-        if (!moduleClass) return null
-        return {
-            moduleClass,
-            options
-        }
-    }
-
-    for (let module of modules) {
-        const moduleObject = getModuleClass(module)
-        if (!moduleObject) continue
-        const { moduleClass } = moduleObject
-        if (moduleClass.hooks) {
-            for (let key in moduleClass.hooks) {
-                if (!hooks[key]) hooks[key] = []
-                hooks[key] = [
-                    ...hooks[key],
-                    ...moduleClass.hooks[key]
-                ]
-            }
-        }
-    }
-
-    for (let module of modules) {
-        const moduleObject = getModuleClass(module)
-        if (!moduleObject) continue
-        const { moduleClass, options } = moduleObject
-        let mod
-        if (options && side == Side.Client && options[Side.Server]) {
-            warning(`Data that may be sensitive (normally visible only on the server side) are made optional and visible on the client side.\nInstead, import the configuration with the server! flag into an import. Example: \n\nimport config from 'server!./config\n\n'`, options[Side.Server])
-        }
-        if (options && !isClass(moduleClass) && isFunction(moduleClass)) {
-            mod = new (moduleClass(options[side]))()
-        }
-        else if (isClass(moduleClass)) {
-            mod = new moduleClass()
-        }
-        else {
-            mod = moduleClass
-        }
-        if (middleware) {
-            mod = middleware(mod)
-            if (isPromise(mod)) {
-                mod = await mod
-            }
-        }
-        const { imports, maps, spritesheets, sounds, gui, scenes, engine, database, worldMaps, scalability, events } = mod
-        if (imports) {
-            await loadModules(imports, obj)
-        }
-        if (maps) {
-            RpgPlugin.on(HookServer.AddMap, () => maps)
-        }
-        if (events) {
-            RpgPlugin.on(HookServer.AddEvent, () => events)
-        }
-        if (worldMaps) {
-            RpgPlugin.on(HookServer.AddWorldMaps, () => worldMaps)
-        }
-        if (database) {
-            RpgPlugin.on(HookServer.AddDatabase, () => database)
-        }
-        if (spritesheets) {
-            RpgPlugin.on(HookClient.AddSpriteSheet, () => spritesheets)
-        }
-        if (sounds) {
-            RpgPlugin.on(HookClient.AddSound, () => sounds)
-        }
-        if (gui) {
-            RpgPlugin.on(HookClient.AddGui, () => gui)
-        }
-        const player = side == Side.Server ? mod.player : mod.sprite
-        const loadRelations = (hook, relationName) => {
-            if (!hook) return
-            for (let method in relations[relationName]) {
-                const hookName = relations[relationName][method]
-                if (hook[method]) RpgPlugin.on(hookName, hook[method])
-            }
-            if (hooks[relationName]) {
-                for (let methodName of hooks[relationName]) {
-                    const hookName = side + '.' + relationName + '.' + methodName
-                    RpgPlugin.customHooks[hookName] = true
-                    if (hook[methodName]) RpgPlugin.on(hookName, hook[methodName])
-                }
-            }
-        }
-        loadRelations(player, 'player')
-        if (player && player.props) {
-            playerProps = Object.assign(playerProps, player.props)
-        }
-        loadRelations(engine, 'engine')
-        if (scalability) loadRelations(scalability._hooks, 'scalability')
-        if (scenes) loadRelations(scenes.map, 'sceneMap')
-    }
-
-    return {
-        playerProps
-    }
-}

package/src/Plugin.ts

@@ -1,100 +0,0 @@
-import { EventEmitter } from './EventEmitter'
-import { isArray } from './Utils'
-
-type PluginFunction = (obj: any, options?: any) => void
-type PluginSides = { client: null | PluginFunction, server:  null | PluginFunction }
-export type Plugin = PluginSides | [PluginSides, any]
-
-export enum HookServer {
-    Start = 'Server.Start',
-    Step = "Server.Step",
-    Auth = "Server.Auth",
-    PlayerConnected = 'Server.onConnected',
-    PlayerDisconnected = 'Server.onDisconnected',
-    AddMap = 'Server.AddMap',
-    AddEvent = 'Server.AddEvent',
-    AddWorldMaps = 'Server.AddWorldMaps',
-    AddDatabase = 'Server.AddDatabase',
-    PlayerInput = 'Server.onInput',
-    PlayerJoinMap = 'Server.onJoinMap',
-    PlayerLeaveMap = 'Server.onLeaveMap',
-    PlayerLevelUp = 'Server.onLevelUp',
-    PlayerDead = 'Server.onDead',
-    PlayerInShape = 'Server.onInShape',
-    PlayerOutShape = 'Server.onOutShape',
-    PlayerMove = 'Server.PlayerMove',
-    PlayerCanChangeMap = 'Server.PlayerCanChangeMap',
-    ScalabilityPlayerConnected = 'Server.ScalabilityPlayerConnected',
-    ScalabilityChangeServer = 'Server.ScalabilityChangeServer'
-}
-
-export enum HookClient {
-    Start = 'Client.Start',
-    Step = 'Client.Step',
-    Connected = 'Client.Connected',
-    Disconnect = 'Client.Disconnect',
-    ConnectedError = 'Client.ConnectedError',
-
-    AddSpriteSheet = 'Client.AddSpriteSheet',
-    AddGui = 'Client.AddGui',
-    AddSound = 'Client.AddSound',
-    SendInput = 'Client.SendInput',
-
-    BeforeSceneLoading = 'Client.BeforeSceneLoading',
-    AfterSceneLoading = 'Client.AfterSceneLoading',
-    SceneMapLoading = 'Client.SceneMapLoading',
-    SceneAddSprite = 'Client.SceneAddSprite',
-    SceneOnChanges = 'Client.SceneOnChanges',
-    SceneDraw = 'Client.SceneDraw',
-    SceneRemoveSprite = 'Client.SceneRemoveSprite',
-
-    AddSprite = 'Client.AddSprite',
-    RemoveSprite = 'Client.RemoveSprite',
-    UpdateSprite = 'Client.UpdateSprite',
-    ChangesSprite = 'Client.ChangesSprite',
-    WindowResize = 'Client.WindowResize',
-    SpriteMove = 'Client.SpriteMove'
-}
-
-/**
- * @deprecated
- */
-export class PluginSystem extends EventEmitter {
-    customHooks: {
-        [key: string]: boolean
-    } = {}
-
-    customHookExists(name: string): boolean {
-        return this.customHooks[name]
-    }
-    
-    private loadPlugins(plugins: Plugin[], shared: any, type: string) {
-        if (!plugins) return
-        for (let plugin of plugins) {
-            if (!plugin) continue
-            let plug: any = []
-            if (!isArray(plugin)) {
-                plug = [plugin]
-            }
-            else {
-                plug = plugin
-            }
-            const [side, options] = plug
-            if (!side[type]) continue
-            side[type]({
-                RpgPlugin,
-                ...shared
-            }, options)
-        }
-    }
-
-    loadServerPlugins(plugins, shared) {
-        this.loadPlugins(plugins, shared, 'server')
-    }
-
-    loadClientPlugins(plugins, shared) {
-        this.loadPlugins(plugins, shared, 'client')
-    }
-}
-
-export const RpgPlugin = new PluginSystem()

package/src/Scheduler.ts

@@ -1,95 +0,0 @@
-import { Tick } from '@rpgjs/types';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { EventEmitter } from './EventEmitter';
-import Utils from './Utils';
-
-export class Scheduler extends EventEmitter {
-    private maxFps?: number
-    private fps: number = 60
-    private deltaTime: number = 0
-    public frame: number = 0
-    private timestamp: number = 0
-    private requestedDelay: number = 0
-    private lastTimestamp: number = 0
-    private _tick: BehaviorSubject<Tick> = new BehaviorSubject({
-        timestamp: 0,
-        deltaTime: 0,
-        frame: 0,
-        deltaRatio: 0
-    })
-    private _stop: boolean = false
-
-    get tick(): Observable<Tick> {
-        return this._tick.asObservable()
-    }
-
-    nextTick(timestamp: number) {
-        this.lastTimestamp = this.lastTimestamp || this.timestamp // first
-        this.deltaTime =  Utils.preciseNow() - this.timestamp
-        this.timestamp = timestamp
-        this._tick.next({
-            timestamp: this.timestamp,
-            deltaTime: this.deltaTime,
-            frame: this.frame,
-            deltaRatio: ~~this.deltaTime / ~~Utils.fps2ms(this.fps)
-        })
-        this.lastTimestamp = this.timestamp
-        this.frame++
-    }
-
-    /**
-     * start the schedule
-     * @return {Scheduler} returns this scheduler instance
-     */
-    start(options: {
-        maxFps?: number
-        fps?: number,
-        delay?: number
-    }) {
-        if (options.maxFps) this.maxFps = options.maxFps
-        if (options.fps) this.fps = options.fps
-        if (options.delay) this.requestedDelay = options.delay
-        const requestAnimationFrame = (fn: (timestamp: number) => void) => {
-            if (Utils.isBrowser()) {
-                window.requestAnimationFrame(fn.bind(this))
-            }
-            else {
-                setTimeout(() => {
-                    this.requestedDelay = 0
-                    fn(Utils.preciseNow())
-                }, Utils.fps2ms(this.fps) + this.requestedDelay)
-            }
-        }
-
-        if (!this.maxFps) {
-            const loop = (timestamp: number) => {
-                requestAnimationFrame(loop)
-                this.nextTick(timestamp)
-            }
-            requestAnimationFrame(loop)
-        }
-        else {
-            const msInterval = Utils.fps2ms(this.maxFps)
-            let now = Utils.preciseNow()
-            let then = Utils.preciseNow()
-            const loop = (timestamp: number) => {
-                if (this._stop) return
-                requestAnimationFrame(loop)
-                now = Utils.preciseNow()
-                const elapsed = now - then
-                if (elapsed > msInterval) {
-                    then = now - (elapsed % msInterval)
-                    this.nextTick(timestamp)
-                }
-            }
-            requestAnimationFrame(loop)
-        }
-
-        return this;
-    }
-
-    stop() {
-        this._stop = true
-        this._tick.complete()
-    }
-}