@rpgjs/common 3.3.2 → 4.0.0-beta.10

package/src/Utils.ts

@@ -0,0 +1,168 @@
+import { constructor } from "@rpgjs/types";
+
+export function random(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1) + min)
+}
+
+export function isBrowser(): boolean {
+    return typeof window !== 'undefined'
+}
+
+export function isFunction(val: unknown): boolean {
+    return {}.toString.call(val) === '[object Function]'
+}
+
+export function isClass(func: unknown): boolean {
+    return typeof func === 'function'
+        && /^class\s/.test(Function.prototype.toString.call(func));
+}
+
+export function isPromise(val: unknown) {
+    return isInstanceOf<Promise<unknown>>(val, Promise)
+}
+
+export function isArray(val: unknown) {
+    return isInstanceOf<Array<unknown>>(val, Array)
+}
+
+export function isObject(val: unknown): boolean {
+    return typeof val == 'object' && val != null && !isArray(val)
+}
+
+export function isString(val: unknown): boolean {
+    return typeof val == 'string'
+}
+
+export function isInstanceOf<T = any>(val: unknown, _class: any) {
+    return val instanceof _class
+}
+
+export function arrayUniq(array: any[]): any[] {
+    return [...new Set(array)]
+}
+
+export function arrayFlat(array: any[]): any[] {
+    return array.reduce((acc, val) => acc.concat(val), [])
+}
+
+export function intersection([start1, end1]: [number, number], [start2, end2]: [number, number]): boolean {
+    return (start1 >= start2 && start1 <= end2) || (start2 >= start1 && start2 < end1)
+}
+
+export function capitalize(s: unknown): string {
+    if (typeof s !== 'string') return ''
+    return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+export function arrayEquals(a: any[], b: any[]): boolean {
+  return a.length === b.length && a.every((v, i) => v === b[i])
+}
+
+export function applyMixins(derivedCtor: constructor<any>, baseCtors: constructor<any>[]) {
+    baseCtors.forEach((baseCtor) => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+        const baseCtorName = Object.getOwnPropertyDescriptor(baseCtor.prototype, name)
+        if (!baseCtorName) {
+            return
+        }
+            Object.defineProperty(derivedCtor.prototype, name, baseCtorName)
+        })
+    })
+}
+
+export function generateUID(): string {
+    let firstPart: any = (Math.random() * 46656) | 0
+    let secondPart: any = (Math.random() * 46656) | 0
+    firstPart = ("000" + firstPart.toString(36)).slice(-3)
+    secondPart = ("000" + secondPart.toString(36)).slice(-3)
+    return firstPart + secondPart
+}
+
+export function createConstructor<T>(...propNames: any[]): T {
+    return class {
+        constructor(...propValues){
+            propNames.forEach((name, idx) => {
+                this[name] = propValues[idx]
+            })
+        }
+    } as unknown as T
+}
+
+export function sharedArrayBuffer() {
+    let buffer
+    if (typeof SharedArrayBuffer != 'undefined') {
+        buffer = SharedArrayBuffer
+    }
+    else {
+        buffer = ArrayBuffer
+    }
+    return buffer
+}
+
+export function toRadians(angle: number) {
+    return angle * (Math.PI / 180)
+}
+
+export function hexaToNumber(hexa: string): {
+    value: number,
+    alpha: number
+} {
+    let val = hexa.replace('#', '')
+    let alpha = 1
+    if (val.length === 3) {
+        val = val.split('').map((v) => v + v).join('')
+    }
+    if (val.length === 8) {
+        alpha = parseInt(val.substring(0, 2), 16) / 255
+        val = val.substring(2)
+    }
+    return {
+        value: parseInt(val, 16),
+        alpha
+    }
+}
+
+export function extractId(path: string): string | null {
+    const id = path.match(/([a-zA-Z0-9-_$!]+)\.[a-z]+$/i)
+    if (!id) return null
+    return id[1]
+}
+
+export function basename(path: string): string {
+    return path.substring(path.lastIndexOf('/') + 1)
+}
+
+export function fps2ms(fps: number): number {
+    return 1000 / fps
+}
+
+export function preciseNow(): number {
+    return typeof performance !== 'undefined' ? performance.now() : Date.now()
+}
+
+export default {
+    random,
+    isBrowser,
+    isPromise,
+    isArray,
+    isObject,
+    isString,
+    isFunction,
+    isClass,
+    isInstanceOf,
+    arrayUniq,
+    arrayFlat,
+    arrayEquals,
+    intersection,
+    applyMixins,
+    capitalize,
+    sharedArrayBuffer,
+    generateUID,
+    createConstructor,
+    toRadians,
+    extractId,
+    basename,
+    fps2ms,
+    preciseNow,
+    hexaToNumber
+}

package/src/Vector2d.ts

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

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

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

@@ -0,0 +1,204 @@
+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)
+    }
+}

package/src/gui/PrebuiltGui.ts

@@ -0,0 +1,27 @@
+ /** 
+ * 
+ * Pre-made GUIs already exist. For example, the command `player.showText()` displays the rpg-dialog component. It is up to you to customize the component or take advantage of the `@rpgjs/default-gui` module which already contains ready-made components
+ * 
+ * @title Prebuilt GUI
+ * @enum {string}
+ * 
+ * PrebuiltGui.Dialog | rpg-dialog
+ * PrebuiltGui.MainMenu | rpg-main-menu
+ * PrebuiltGui.Shop | rpg-shop
+ * PrebuiltGui.Disconnect | rpg-disconnect
+ * PrebuiltGui.Gameover | rpg-gameover
+ * PrebuiltGui.Save | rpg-save
+ * PrebuiltGui.Controls | rpg-controls
+ * PrebuiltGui.Notification | rpg-notification
+ * @memberof PrebuiltGui
+ * */
+export enum PrebuiltGui {
+    Dialog = 'rpg-dialog',
+    MainMenu = 'rpg-main-menu',
+    Shop = 'rpg-shop',
+    Disconnect = 'rpg-disconnect',
+    Gameover = 'rpg-gameover',
+    Save = 'rpg-save',
+    Controls = 'rpg-controls',
+    Notification = 'rpg-notification'
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+import AbstractObject from './Player';
+export { LiteralDirection, RpgCommonPlayer } from './Player'
+export { AbstractObject }
+export { RpgCommonEvent } from './Event'
+export { RpgCommonMap } from './Map'
+export { RpgCommonGame, GameSide } from './Game'
+export { EventEmitter } from './EventEmitter'
+export { PrebuiltGui } from './gui/PrebuiltGui'
+export  *as Utils from './Utils'
+export { RpgPlugin, Plugin, HookServer, HookClient } from './Plugin'
+export * as TransportIo from './transports/io'
+export { Input, Control } from '@rpgjs/types'
+export { Hit } from './Hit'
+export { Scheduler } from './Scheduler'
+export { RpgModule, loadModules, ModuleType } from './Module'
+export * as MockIo from './transports/io'
+export * as Logger from './Logger';
+export { RpgShape, ShapePositioning } from './Shape'
+export { VirtualGrid } from './VirtualGrid'
+export { RpgCommonWorldMaps } from './WorldMaps'
+export { Vector2d } from './Vector2d'
+export { Direction } from '@rpgjs/types'
+export { transitionColor } from './Color'
+export { DefaultInput } from './DefaultInput'

package/src/transports/io.ts

@@ -0,0 +1,91 @@
+class MockIo {
+    events: Map<string, any> = new Map()
+
+    on(name: string, value) {
+        this.events.set(name, value)
+    }
+
+    off(name: string) {
+        this.events.delete(name)
+    }
+
+    once(name: string, value) {
+        this.on(name, value)
+    }
+
+    _trigger(name: string, data, client?) {
+        const fn = this.events.get(name)
+        if (fn) fn(data, client)
+    }
+}
+
+class MockSocket {
+    id: string
+
+    constructor(private io: any, public handshake) {
+        this.id = ''+Math.random()
+    }
+    
+    on(name: string, value) {
+        this.io.on(name, value, this.id)
+        return this
+    }
+
+    once(name: string, value) {
+        this.io.once(name, value, this.id)
+        return this
+    }
+
+    emit(name: string, data) {
+        this.io.emit(name, data, this.id)
+    }
+
+    removeAllListeners(name: string) {
+        return this.off(name)
+    }
+
+    off(name: string) {
+        this.io.off(name, this.id)
+    }
+}
+
+class MockClientIo extends MockIo {
+    id: string = ''
+
+    connection(handshake: any) {
+        serverIo.connection(this, handshake)
+        this._trigger('connect', undefined)
+        return this
+    }
+
+    emit(name: string, data) {
+        serverIo._trigger(name, data, this)
+        return this
+    }
+
+    disconnect() {
+        this.emit('disconnect', undefined)
+    }
+}
+
+class MockServerIo extends MockIo {
+    private clients: Map<string, MockClientIo> = new Map()
+
+    connection(client, handshake) {
+        const socket = new MockSocket(this, handshake)
+        this.clients.set(socket.id, client)
+        client.id = socket.id
+        this._trigger('connection', socket)
+    }
+
+    emit(name: string, data, id) {
+        this.clients.get(id)?._trigger(name, data)
+    }
+
+    clear() {
+        this.clients.clear()
+    }
+}
+
+export const serverIo = new MockServerIo()
+export const ClientIo = MockClientIo