@rpgjs/common 4.3.0 → 5.0.0-alpha.1

package/src/Shape.ts

@@ -1,302 +0,0 @@
-import { RpgCommonPlayer } from './Player'
-import { Hit, HitType } from './Hit'
-import { TiledObjectClass } from '@rpgjs/tiled'
-import { PlayerType } from '@rpgjs/types'
-import { Vector2d } from './Vector2d'
-import { AbstractObject } from './AbstractObject'
-
-export enum ShapePositioning {
-    Default = 'default',
-    Center = 'center'
-}
-
-type ShapeObject = TiledObjectClass & {
-    onIn?(player: RpgCommonPlayer)
-    onOut?(player: RpgCommonPlayer)
-    fixEvent?: RpgCommonPlayer,
-    positioning?: ShapePositioning
-}
-
-export class RpgShape extends TiledObjectClass {
-    _hitbox: any
-    type: string = HitType.Box
-    class: string = ''
-    /**
-    * Get/Set name
-    * @title name
-    * @prop { string } name
-    * @memberof Shape
-    */
-    name: string = ''
-    fixEvent?: RpgCommonPlayer
-    private playersIn: {
-        [playerid: string]: boolean
-    } = {}
-    private onIn: (player: RpgCommonPlayer) => void
-    private onOut: (player: RpgCommonPlayer) => void
-    clientContainer: any = null
-    /**
-    * Get/Set positioning
-    * @title positioning
-    * @prop { ShapePositioning } positioning
-    * @default default
-    * @memberof Shape
-    */
-    positioning?: ShapePositioning = ShapePositioning.Default
-    components: any[] = []
-
-    constructor(obj: ShapeObject) {
-        super()
-        Reflect.deleteProperty(obj, 'id')
-        this.set(obj)
-    }
-
-    private setPos(type: string, val: number) {
-        if (!this.hitbox.pos) return
-        if (this.isShapePosition()) {
-            this.hitbox[type] = val
-        }
-        else {
-            this.hitbox.pos[type] = val
-        }
-    }
-
-    get hasCollision(): boolean {
-        return this.getProperty<boolean, boolean>('collision', false)
-    }
-
-    // alias
-    get id(): any {
-        return this.name
-    }
-
-    get hitbox() {
-        if (this.fixEvent) {
-            this._hitbox.pos.x = this.fixEvent.position.x
-            this._hitbox.pos.y = this.fixEvent.position.y
-            switch (this.positioning) {
-                case ShapePositioning.Center:
-                    this._hitbox.pos.x -= this._hitbox.w / 2 - this.fixEvent.hitbox.w / 2
-                    this._hitbox.pos.y -= this._hitbox.h / 2 - this.fixEvent.hitbox.h / 2
-                    break
-            }
-        }
-        return this._hitbox
-    }
-
-    set hitbox(val) {
-        this._hitbox = val
-    }
-
-    /**
-    * Get/Set width
-    * @title width
-    * @prop { number } width
-    * @since 3.0.0-beta.5
-    * @memberof Shape
-    */
-    get width(): number {
-        return this.hitbox.w || 0
-    }
-
-    set width(val: number) {
-        this.setPos('w', val)
-    }
-
-    /**
-    * Get/Set height
-    * @title height
-    * @prop { number } height
-    * @since 3.0.0-beta.5
-    * @memberof Shape
-    */
-    get height(): number {
-        return this.hitbox.h || 0
-    }
-
-    set height(val: number) {
-        this.setPos('h', val)
-    }
-
-    /**
-    * Get/Set x
-    * @title x
-    * @prop { number } x
-    * @memberof Shape
-    */
-    get x(): number {
-        return this.hitbox.x || this.hitbox.pos.x
-    }
-
-    set x(val: number) {
-        this.setPos('x', val)
-    }
-
-    get z(): number | undefined {
-        return this.getProperty<number>('z')
-    }
-
-    /**
-    * Get/Set y
-    * @title y
-    * @prop { number } y
-    * @memberof Shape
-    */
-    get y(): number {
-        return this.hitbox.y || this.hitbox.pos.y
-    }
-
-    set y(val: number) {
-        this.setPos('y', val)
-    }
-
-    get position(): Vector2d {
-        return new Vector2d(this.x, this.y, this.z)
-    }
-
-    /**
-    * Get/Set properties
-
-    * @title Properties
-    * @prop { object } Properties
-    * @memberof Shape
-    */
-
-    isEvent(): boolean {
-        return this.type == PlayerType.Event
-    }
-
-    set(obj: ShapeObject) {
-        const hit = Hit.getHitbox(obj)
-        Object.assign(this, hit)
-        const objClone = { ...obj };
-        // Delete dimension and position because already managed and given by the hitbox above
-        ['width', 'height', 'x', 'y'].forEach((prop) => Reflect.deleteProperty(objClone, prop))
-        Object.assign(this, objClone)
-        const findPoint = (prop: string, isMin: boolean) => {
-            return this.hitbox.points.sort((a, b) => isMin ? a[prop] - b[prop] : b[prop] - a[prop])[0][prop]
-        }
-        if (this.type == HitType.Polygon) {
-            this.hitbox.minX = findPoint('x', true)
-            this.hitbox.maxX = findPoint('x', false)
-            this.hitbox.minY = findPoint('y', true)
-            this.hitbox.maxY = findPoint('y', false)
-        }
-        this.positioning = obj.positioning
-        this.fixEvent = obj.fixEvent
-        this.setComponent()
-    }
-
-    setComponent() {
-        const color = this.getProperty<string>('color')
-        const image = this.getProperty<string>('image')
-        if (color) {
-            this.components = [{
-                id: 'shape', value: {
-                    fill: color
-                }
-            }]
-            return
-        }
-        if (image) {
-            this.components = [{ id: 'image', value: image }]
-            return
-        }
-        if (this.text) {
-            this.components = [{ id: 'text', value: this.text.text }]
-            return
-        }
-        if (this.gid) {
-            this.components = [{ id: 'tile', value: this.gid }]
-            return
-        }
-    }
-
-    getType() {
-        return this.class || this.type
-    }
-
-    async in(player: AbstractObject): Promise<boolean> {
-        if (!this.playerIsIn(player)) {
-            this.playersIn[player.id] = true
-            player.inShapes[this.name] = this
-            await player.execMethod('onInShape', [this])
-            await this.fixEvent?.execMethod('onDetectInShape', [player, this], this.fixEvent)
-            await player.execMethod('onIn', [player], this)
-            return true
-        }
-        return false
-    }
-
-    async out(player: AbstractObject): Promise<boolean> {
-        if (this.playerIsIn(player)) {
-            delete this.playersIn[player.id]
-            delete player.inShapes[this.name]
-            await player.execMethod('onOutShape', [this])
-            await this.fixEvent?.execMethod('onDetectOutShape', [player, this], this.fixEvent)
-            await player.execMethod('onOut', [player], this)
-            return true
-        }
-        return false
-    }
-
-    /**
-     * Whether the player is in this shape
-     * 
-     * @title Player is in this shape ?
-     * @method shape.playerIsIn(player)
-     * @returns {boolean}
-     * @memberof Shape
-     */
-    playerIsIn(player: AbstractObject): boolean {
-        return !!this.playersIn[player.id]
-    }
-
-    isShapePosition(): boolean {
-        return this.type !== HitType.Box && this.type !== HitType.Circle && this.type !== HitType.Polygon
-    }
-
-    /**
-      * Recover the player with the shape. You must have used the `attachShape()` method on the player
-      * 
-      * @title Get Player Owner
-      * @method shape.getPlayerOwner()
-      * @returns {RpgPlayer | undefined}
-      * @memberof Shape
-      */
-    getPlayerOwner(): RpgCommonPlayer | undefined {
-        return this.fixEvent
-    }
-
-    /**
-     * We get the rectangle of a shape (box, circle and polygon). We use in the grid system to recover a shape.
-     * Generally we add a margin (size of a tile) to detect if the player enters or leaves a shape
-     * @param margin 
-     * @returns { minX: number, minY: number, maxX: number, maxY: number }
-     */
-    getSizeBox(margin: number = 0): { minX: number, minY: number, maxX: number, maxY: number } {
-        if (this.type == HitType.Circle) {
-            const radius = this.hitbox.r
-            return {
-                minX: this.x - radius - margin,
-                maxX: this.x + radius + margin,
-                minY: this.y - radius - margin,
-                maxY: this.y + radius + margin
-            }
-        }
-        if (this.type == HitType.Polygon) {
-            return {
-                minX: this.x + this.hitbox.minX - margin,
-                maxX: this.x + this.hitbox.maxX + margin,
-                minY: this.y + this.hitbox.minY - margin,
-                maxY: this.y + this.hitbox.maxY + margin
-            }
-        }
-        return {
-            minX: this.x - margin,
-            maxX: this.x + this.width + margin,
-            minY: this.y - margin,
-            maxY: this.y + this.height + margin
-        }
-    }
-}

package/src/Vector2d.ts

@@ -1,70 +0,0 @@
-export class Vector2d {
-    constructor(public x: number, public y: number, public z: number = 0) {}
-
-    set(vector: Vector2d) {
-        this.x = vector.x
-        this.y = vector.y
-        this.z = vector.z
-        return this
-    }
-    
-    add(vector: Vector2d) {
-        this.x += vector.x
-        this.y += vector.y
-        return this
-    }
-
-    subtract(vector: Vector2d) {
-        this.x -= vector.x
-        this.y -= vector.y
-        return this
-    }
-
-    multiply(scalar: number) {
-        this.x *= scalar
-        this.y *= scalar
-        return this
-    }
-
-    divide(scalar: number) {
-        this.x /= scalar
-        this.y /= scalar
-        return this
-    }
-
-    distanceWith(vector: Vector2d): number {
-        const dx = this.x - vector.x
-        const dy = this.y - vector.y
-        return Math.sqrt(dx ** 2 + dy ** 2)
-    }
-
-    magnitude(): number {
-        return Math.sqrt(this.x * this.x + this.y * this.y)
-    }
-
-    copy(): Vector2d {
-        return new Vector2d(this.x, this.y, this.z)
-    }
-
-    normalize() {
-        return this.divide(this.magnitude())
-    }
-
-    isEqual(vector: Vector2d): boolean {
-        return this.x === vector.x && 
-        this.y === vector.y &&
-        this.z === vector.z
-    }
-
-    hasDifferentValues(vector: Vector2d): boolean {
-        return this.x !== vector.x || 
-        this.y !== vector.y ||
-        this.z !== vector.z
-    }
-}
-
-export class Vector2dZero extends Vector2d {
-    constructor() {
-        super(0, 0)
-    }
-}

package/src/VirtualGrid.ts

@@ -1,78 +0,0 @@
-export type Box = { minX: number, minY: number, maxX: number, maxY: number }
-
-export class VirtualGrid {
-    private cells: Map<number, Set<string>> = new Map()
-    private inverseCells: Map<string, Set<number>> = new Map()
-
-    constructor(private nbCellWidth: number, private cellWidth: number, private cellHeight: number) {}
-
-    zoom(nbCell: number): VirtualGrid {
-        this.nbCellWidth = Math.ceil(this.nbCellWidth / nbCell)
-        this.cellWidth *= nbCell
-        this.cellHeight *= nbCell
-        return this
-    }
-
-    getCellIndex(x: number, y: number) {
-        return this.nbCellWidth * Math.floor(y / this.cellHeight) + Math.floor(x / this.cellWidth) 
-    }
-
-    getCells(box: Box, cb: (index: number) => void) {
-        const {
-            minX,
-            minY,
-            maxX,
-            maxY
-        } = box
-        const topLeft = this.getCellIndex(minX, minY)
-        const topRight = this.getCellIndex(maxX, minY)
-        const bottomLeft = this.getCellIndex(minX, maxY)
-        const nbLines = (bottomLeft - topLeft) / this.nbCellWidth + 1
-        for (let j=0 ; j < nbLines ; j++) {
-            for (let i = topLeft ; i <= topRight ; i++) {
-                const index = i + (j * this.nbCellWidth)
-                cb(index)
-            }
-        }
-    }
-
-    getObjectsByBox(box: Box): Set<string> {
-        let objects: string[] = []
-        this.getCells(box, (index) => {
-            objects = [...objects, ...this.cells.get(index) || []]
-        })
-        return new Set(objects)
-    }
-
-    getObjectsById(id: string): Set<string> {
-        let objects: string[] = []
-        const cells = this.inverseCells.get(id)
-        cells?.forEach((index) => {
-            objects = [...objects, ...this.cells.get(index) || []]
-        })
-        return new Set(objects)
-    }
-
-    clearObjectInCells(id: string) {
-        if (this.inverseCells.has(id)) {
-            this.inverseCells.get(id)?.forEach((cellIndex: number) => {
-                this.cells.get(cellIndex)?.delete(id)
-            })
-            this.inverseCells.delete(id)
-        }
-    }
-
-    insertInCells(id: string, box: { minX: number, minY: number, maxX: number, maxY: number }) {
-        this.clearObjectInCells(id)
-        const cells: Set<number> = new Set()
-        this.getCells(box, (index) => {
-            cells.add(index)
-            const memoryCells = this.cells.get(index)
-            if (!memoryCells) {
-                this.cells.set(index, new Set())
-            }
-            this.cells.get(index)?.add(id)
-        })
-        this.inverseCells.set(id, cells)
-    }
-}

package/src/Worker.ts

@@ -1,17 +0,0 @@
-import workerpool from 'workerpool'
-
-export class GameWorker {
-    pool: any
-
-    constructor(private options = {}) {
-        //this.pool = workerpool.pool(__dirname + '/workers/move.js', options)
-    }
-
-    load() {
-        return this
-    } 
-
-    call(methodName: string, data: any) {
-       return this.pool.exec(methodName, [data])
-    }
-}

package/src/WorldMaps.ts

@@ -1,204 +0,0 @@
-import RBush from 'rbush'
-import { TiledWorldMap } from '@rpgjs/tiled'
-import { RpgCommonMap } from './Map'
-import { Direction } from '@rpgjs/types'
-
-export interface RpgClassMap<T> {
-    id?: string
-    new (server: any): T,
-}
-
-export interface RpgTiledWorldMap extends TiledWorldMap{
-    properties?: {
-        [key: string]: any
-    }
-}
-
-type PositionBox = { minX: number, minY: number, maxX: number, maxY: number }
-type MapTree = { map: RpgClassMap<RpgCommonMap> } & PositionBox
-
-export class RpgCommonWorldMaps {
-    private mapsTree: RBush = new RBush(500)
-    private maps: Map<string, RpgTiledWorldMap> = new Map()
-
-    constructor(public id: string) {}
-
-    /**
-     * Adding information from the map to the world
-     *
-     * > Maximum maps in world: 500
-     * 
-     * @title Add Map in world
-     * @method world.addMap(wordMapInfo,map)
-     * @param {object} wordMapInfo 
-     * Object file:
-     * ```ts
-     * {
-     *  fileName: string;
-        height: number;
-        width: number;
-        x: number;
-        y: number;
-     * }
-        ```
-        `fileName` represents a file to the JSON file (TMX transformed) or directly the Tiled Map Editor object
-     * 
-     * @param {class of RpgMap} map 
-     * @since 3.0.0-beta.8
-     * @memberof RpgWorldMaps
-     */
-    addMap(wordMapInfo: RpgTiledWorldMap, map: RpgClassMap<RpgCommonMap>) {
-        const { x, y, height, width } = wordMapInfo
-        map.prototype.worldMapParent = this
-        this.maps.set(map.id as string, wordMapInfo)
-        this.mapsTree.insert<MapTree>({
-            minX: x,
-            minY: y,
-            maxX: x + width,
-            maxY: y + height,
-            map
-        })
-    }
-
-    updateMap(mapId: string, wordMapInfo: RpgTiledWorldMap): boolean {
-        const map = this.maps.get(mapId)
-        if (map) {
-            const item = (this.mapsTree.all() as MapTree[]).find(item => item.map.id == mapId)
-            if (!item) return false
-            this.maps.set(mapId, wordMapInfo)
-            item.map.prototype.worldMapParent = this
-            item.minX = wordMapInfo.x
-            item.minY = wordMapInfo.y
-            item.maxX = wordMapInfo.x + wordMapInfo.width
-            item.maxY = wordMapInfo.y + wordMapInfo.height
-            return true
-        }
-        return false
-    }
-
-    /**
-     * Remove map of the world
-     * @title Remove map of the world
-     * @method world.removeMap(mapId)
-     * @param {string} mapId 
-     * @returns {boolean}
-     * @since 3.0.0-beta.8
-     * @memberof RpgWorldMaps
-     */
-    removeMap(mapId: string): boolean {
-        const map = this.maps.get(mapId)
-        if (map) {
-            const item = (this.mapsTree.all() as MapTree[]).find(item => item.map.id == mapId)
-            if (!item) return false
-            this.maps.delete(mapId)
-            item.map.prototype.worldMapParent = undefined
-            this.mapsTree.remove(item)
-            return true
-        }
-        return false
-    }
-
-    removeAllMaps() {
-        this.maps.forEach((map, id) => {
-            this.removeMap(id)
-        })
-    }
-
-    /**
-     * Retrieve information from the world
-     * 
-     * @title Retrieve information from the world
-     * @method world.getMapInfo(id)
-     * @param {string} id map id
-     * @return {RpgTiledWorldMap | undefined}
-     * {
-     *  id?: string
-     *  properties?: object
-     *  fileName: string;
-        height: number;
-        width: number;
-        x: number;
-        y: number;
-     * }
-     * @since 3.0.0-beta.8
-     * @memberof RpgWorldMaps
-     */
-    getMapInfo(id: string): RpgTiledWorldMap | undefined {
-        return this.maps.get(id)
-    }
-
-    /**
-     * Retrieves neighboring maps according to positions or direction
-     * 
-     * @title Retrieves neighboring maps
-     * @method world.getAdjacentMaps(map,search)
-     * @param {RpgMap} map The source map. We want to find the neighboring maps of the source map
-     * @param { PositionBox | Direction | { x: number, y: number } } search Research method
-     *  * PositionBox. An object of the following form:
-     *  `{ minX: number, minY: number, maxX: number, maxY: number }`
-     *  * Direction. Collect all the maps in the given direction (e.g. the maps at the top)
-     *  * Point: { x: number, y: number }
-     * @return { {class of RpgMap}[] }
-     * @since 3.0.0-beta.8
-     * @example
-     * ```ts
-     * world.getAdjacentMaps(mymap, Direction.Up) // returns [class of RpgMap]
-     * ```
-     * @memberof RpgWorldMaps
-     */
-    getAdjacentMaps(map: RpgCommonMap, search: PositionBox | Direction | { x: number, y: number }): RpgClassMap<RpgCommonMap>[] {
-        let position: PositionBox = {} as PositionBox
-        const point = search as { x: number, y: number }
-        if (typeof search == 'number') {
-            const padding = 1
-            switch (search) {
-                case Direction.Up:
-                    position = {
-                        minX: map.worldX + padding,
-                        maxX: map.worldX + map.widthPx - padding,
-                        minY: map.worldY - padding - 1,
-                        maxY: map.worldY - padding 
-                    }
-                    break;
-                case Direction.Right:
-                    position = {
-                        minX: map.worldX + map.widthPx + padding,
-                        maxX: map.worldX + map.widthPx + padding + 1,
-                        minY: map.worldY + padding,
-                        maxY: map.worldY + map.heightPx - padding
-                    }
-                    break;
-                case Direction.Down:
-                    position = {
-                        minX: map.worldX + padding,
-                        maxX: map.worldX + map.widthPx - padding,
-                        minY: map.worldY + map.heightPx + padding,
-                        maxY: map.worldY + map.heightPx + padding + 1
-                    }
-                    break;
-                case Direction.Left:
-                    position = {
-                        minX: map.worldX - padding,
-                        maxX: map.worldX - padding - 1,
-                        minY: map.worldY + padding,
-                        maxY: map.worldY + map.heightPx - padding
-                    }
-                    break;
-            }
-            
-        }
-        else if (point.x) {
-            position = {
-                minX: point.x,
-                maxX: point.x,
-                minY: point.y,
-                maxY: point.y
-            }
-        }
-        else {
-            position = search as PositionBox
-        }
-        const result = this.mapsTree.search(position)
-        return result.map(ret => ret.map)
-    }
-}