@rpgjs/common 4.2.1 → 5.0.0-alpha.0

package/src/Color.ts

@@ -1,29 +0,0 @@
-type RGB = [number, number, number];
-
-function hexToRGB(hex: string): RGB {
-    let r = parseInt(hex.substring(0, 2), 16);
-    let g = parseInt(hex.substring(2, 4), 16);
-    let b = parseInt(hex.substring(4, 6), 16);
-    return [r, g, b];
-}
-
-function RGBToHex(rgb: RGB): string {
-    let r = rgb[0].toString(16).padStart(2, '0');
-    let g = rgb[1].toString(16).padStart(2, '0');
-    let b = rgb[2].toString(16).padStart(2, '0');
-    return r + g + b;
-}
-
-export function transitionColor(startColor: string, endColor: string, steps: number): string[] {
-    let startRGB = hexToRGB(startColor.replace('#', ''));
-    let endRGB = hexToRGB(endColor.replace('#', ''));
-    let deltaRGB = [(endRGB[0] - startRGB[0]) / steps, (endRGB[1] - startRGB[1]) / steps, (endRGB[2] - startRGB[2]) / steps];
-
-    let colors: string[] = [];
-    for (let i = 0; i < steps; i++) {
-        let color = [startRGB[0] + deltaRGB[0] * i, startRGB[1] + deltaRGB[1] * i, startRGB[2] + deltaRGB[2] * i];
-        colors.push(RGBToHex(color as any));
-    }
-    colors.push(endColor.replace('#', ''));
-    return colors;
-}

package/src/DefaultInput.ts

@@ -1,26 +0,0 @@
-import { Controls, Input, Control } from '@rpgjs/types'
-
-export const DefaultInput: Controls = {
-    [Control.Up]: {
-        repeat: true,
-        bind: Input.Up
-    },
-    [Control.Down]: {
-        repeat: true,
-        bind: Input.Down
-    },
-    [Control.Right]: {
-        repeat: true,
-        bind: Input.Right
-    },
-    [Control.Left]: {
-        repeat: true,
-        bind: Input.Left
-    },
-    [Control.Action]: {
-        bind: [Input.Space, Input.Enter]
-    },
-    [Control.Back]: {
-        bind: Input.Escape
-    }
-} 

package/src/Event.ts

@@ -1,3 +0,0 @@
-import { RpgCommonPlayer } from './Player'
-
-export class RpgCommonEvent extends RpgCommonPlayer {}

package/src/EventEmitter.ts

@@ -1,65 +0,0 @@
-import { isPromise } from './Utils'
-
-export class EventEmitter {
-    private listeners: {
-        [eventName: string]: Function[]
-    } = {}
-
-    private listenersOnce: {
-        [eventName: string]: Function
-    } = {}
-    
-    has(name: string): boolean {
-        return !!this.listeners[name] || !!this.listenersOnce[name]
-    }
-
-    once(name: string, cb: Function): EventEmitter {
-        this.listenersOnce[name] = cb
-        return this
-    }
-
-    on(name: string, cb: Function): EventEmitter {
-        if (!this.listeners[name]) this.listeners[name] = []
-        this.listeners[name].push(cb)
-        return this
-    }
-
-    emit(name: string, data?: any, rest: boolean = false): Promise<any[]> {
-        const ret: any = []
-        if (this.listeners[name]) {
-            for (let listener of this.listeners[name]) {
-                if (rest) ret.push(listener(...data))
-                else ret.push(listener(data))
-            }
-        }
-        if (this.listenersOnce[name]) {
-            if (rest) ret.push(this.listenersOnce[name](...data))
-            else ret.push(this.listenersOnce[name](data))
-        }
-        return Promise.all(ret.map(val => {
-            if (!isPromise(val)) {
-                return Promise.resolve(val)
-            }
-            return val
-        }))
-    }
-
-    off(name: string, listener?: Function) {
-        if (!listener) {
-            delete this.listeners[name]
-            delete this.listenersOnce[name]
-            return
-        }
-        if (this.listeners[name]) {
-            const index = this.listeners[name].indexOf(listener)
-            if (index !== -1) {
-                this.listeners[name].splice(index, 1)
-            }
-        }
-    }
-
-    clear() {
-        this.listeners = {}
-        this.listenersOnce = {}
-    }
-}

package/src/Game.ts

@@ -1,159 +0,0 @@
-import Utils, { generateUID, isClass } from './Utils'
-import { EventEmitter } from './EventEmitter'
-import { RpgCommonPlayer } from './Player'
-import { constructor, Control, Controls, Direction } from '@rpgjs/types'
-import { RpgPlugin } from './Plugin'
-import { GameWorker } from './Worker'
-import { HitObject } from './Hit'
-import { RpgShape } from './Shape'
-import { TiledObjectClass } from '@rpgjs/tiled'
-import { InjectContext } from './Inject'
-
-export enum GameSide {
-    Server = 'server',
-    Client = 'client',
-    Worker = 'worker'
-}
-
-export class RpgCommonGame extends EventEmitter {
-    events: any
-    world: any
-    side: GameSide
-
-    initialize(side: GameSide) {
-        this.side = side
-        this.events = {} // events for all player in map
-    }
-
-    get isWorker() {
-        return this.side == 'worker'
-    }
-
-    start(world) {
-        this.world = world
-    }
-
-    createWorkers(options: any) {
-        return new GameWorker(options)
-    }
-
-    addObject(_class, playerId?: string) {
-        let event
-        if (!playerId) playerId = generateUID()
-        if (isClass(_class)) {
-            if (this.side == GameSide.Client) {
-                event = new _class(this, playerId)
-            }
-            else {
-                event = new _class(playerId)
-            }
-        }
-        else {
-            event = _class
-        }
-        return event
-    }
-
-    addPlayer(playerClass, playerId?: string) {
-        const player = this.addObject(playerClass, playerId)
-        return player
-    }
-
-    addEvent<T>(eventClass: constructor<T>, eventId?: string): T {
-        const event = this.addObject(eventClass, eventId)
-        return event
-    }
-
-    addShape(obj: HitObject): RpgShape {
-        const id = obj.name = (obj.name || generateUID()) as string
-        const shape = new RpgShape(obj as TiledObjectClass)
-        shape.name = id
-        return shape
-    }
-
-    async processInput<RpgPlayer extends RpgCommonPlayer>(playerId: string, controls?: Controls): Promise<{
-        player: RpgPlayer,
-        inputs: string[]
-    }> {
-        const player: RpgPlayer = this.world.getObject(playerId)
-        const inputs: string[] = []
-
-        if (!player) return {
-            player,
-            inputs
-        }
-
-        const routesMove: any = []
-
-        while (player.pendingMove.length > 0) {
-            const inputData = player.pendingMove.shift()
-            
-            let { input, deltaTimeInt } = inputData as any
-            let moving = false
-
-            if (controls && controls[input]) {
-                const control = controls[input]
-                const now = Date.now()
-                const inputTime = player.inputsTimestamp[input] || 0
-
-                if (inputTime >= now) {
-                    continue
-                }
-
-                if (control.delay) {
-                    let duration: number
-                    let otherControls: (string | Control)[] = []
-
-                    if (typeof control.delay == 'number') {
-                        duration = control.delay
-                    }
-                    else {
-                        duration  = control.delay.duration
-                        if (control.delay.otherControls) {
-                            otherControls = control.delay.otherControls
-                        }
-                    }
-
-                    player.inputsTimestamp[input] = now + duration
-
-                    for (let control of otherControls) {
-                        player.inputsTimestamp[control] = now + duration
-                    }
-                }                
-            }
-            
-            if (input == Control.Action) {
-                await player.triggerCollisionWith(RpgCommonPlayer.ACTIONS.ACTION)
-            }
-            else if (
-                input == Direction.Left ||
-                input == Direction.Right ||
-                input == Direction.Up ||
-                input == Direction.Down
-            ) {
-                player.moving = true
-                moving = true
-                const isMove = await player.moveByDirection(+input, deltaTimeInt || 1)
-                if (isMove) {
-                    routesMove.push(inputData)
-                }
-            }
-            // TODO, is Worker
-            // verify if is server because, rpg mode causes a bug (see #184)
-            if (this.side == GameSide.Server) {
-                await RpgPlugin.emit('Server.onInput', [player, {
-                    ...inputData,
-                    moving
-                }], true)
-            }
-
-            inputs.push(input)
-        }
-
-
-        return {
-            player,
-            inputs
-        }
-    }
-}

package/src/Hit.ts

@@ -1,70 +0,0 @@
-import { HitEllipse, HitObject, HitType } from '@rpgjs/types'
-import  SAT from 'sat'
-import { isInstanceOf } from './Utils'
-export { HitType, HitObject } from '@rpgjs/types'
-
-class HitClass {
-
-    createObjectHitbox(x: number, y: number, z: number, w: number, h: number): SAT.Box {
-        return new SAT.Box(new SAT.Vector(x, y - z), w, h)
-    }
-    
-    getHitbox(obj: HitObject, offset?: { x: number, y: number }): {
-        hitbox: SAT,
-        type?: string,
-        name?: string
-    } {
-        let hitbox: SAT, type: string | undefined
-        if (!offset) offset = { x: 0, y: 0 }
-        const x = obj.x + offset.x
-        const y = obj.y + offset.y
-        if ('ellipse' in obj || obj.type == HitType.Circle) {
-            type = HitType.Circle
-            const radius = (<HitEllipse>obj).width / 2
-            hitbox = new SAT.Circle(new SAT.Vector(x + radius, y + radius), radius)
-        }
-        else if ('polygon' in obj) {
-            type = HitType.Polygon
-            hitbox = new SAT.Polygon(new SAT.Vector(x, y), obj.polygon.map(pos => new SAT.Vector(+pos.x, +pos.y)))
-        }
-        else if (!('polygon' in obj) && ('width' in obj) && ('height' in obj)) {
-            type = HitType.Box
-            hitbox = new SAT.Box(new SAT.Vector(x, y), obj.width, obj.height)
-        }
-        else {
-            hitbox = new SAT.Vector(x, y)
-            type = obj.type
-        }
-        return { 
-            hitbox,
-            type,
-            name: obj.name
-        }
-    }
-
-    testPolyCollision(type: string, hit1: SAT, hit2: SAT): boolean {
-        let collided = false
-        if (type == HitType.Box) {
-            if (hit1.pos.x <= hit2.pos.x + hit2.w &&
-                hit1.pos.x + hit1.w >= hit2.pos.x &&
-                hit1.pos.y <= hit2.pos.y + hit2.h &&
-                hit1.h + hit1.pos.y >= hit2.pos.y) {
-                return true
-             }
-            return false
-        }
-        if (isInstanceOf(hit1, SAT.Box)) hit1 = hit1.toPolygon()
-        if (isInstanceOf(hit2, SAT.Box)) hit2 = hit2.toPolygon()
-        switch (type) {
-            case HitType.Circle:
-                collided = SAT.testPolygonCircle(hit1, hit2)
-            break
-            case HitType.Polygon:
-                collided = SAT.testPolygonPolygon(hit1, hit2)
-            break
-        }
-        return collided
-    }
-}
-
-export const Hit = new HitClass()

package/src/Inject.ts

@@ -1,22 +0,0 @@
-type Constructor<T> = new (...args: any[]) => T;
-type ServiceIdentifier<T> = string;
-
-export class InjectContext {
-    private instances = new Map<ServiceIdentifier<any>, any>();
-
-    inject<T>(constructor: Constructor<T>, args: any[] = []): T {
-        const serviceName = constructor.name;
-        if (!this.instances.has(serviceName)) {
-            const instance = new constructor(this, ...args);
-            if (instance['initialize']) {
-                instance['initialize'](...args);
-            }
-            this.instances.set(serviceName, instance);
-        }
-        return this.instances.get(serviceName);
-    }
-}
-
-export interface InjectInit {
-    initialize(...args: any[]): any
-}

package/src/Logger.ts

@@ -1,7 +0,0 @@
-export function log(message) {
-    return new Error(`[RPGJS] - ${message}`)
-}
-
-export function warning(...message) {
-    console.warn('[RPGJS Warning]', ...message)
-}