@rpgjs/common 4.3.0 → 5.0.0-alpha.0

package/src/transports/io.ts

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

package/src/workers/move.ts

@@ -1,61 +0,0 @@
-import workerpool from 'workerpool'
-import { RpgCommonMap } from '../Map'
-import { RpgCommonGame, GameSide } from '../Game'
-import { RpgCommonPlayer } from '../Player'
-
-const objects: any = {}
-let objectsByMap: any = {}
-const gameEngine = new RpgCommonGame()
-gameEngine.start({
-  getObject(playerId) {
-    return objects[playerId]
-  },
-  addObject(playerId, data) {
-    const player = gameEngine.addPlayer(RpgCommonPlayer, playerId)
-    for (let key in data) {
-      player[key] = data[key]
-    }
-    if (player.hitbox) {
-      player.setHitbox(player.hitbox.width, player.hitbox.height)
-    }
-    objects[playerId] = player
-    objectsByMap[player.map] = player
-    return player
-  },
-  getObjectsOfGroup(mapId, player) {
-    return {}
-  }
-})
-
-let i=0
-
-function loadMap(data) {
-  const map = new RpgCommonMap()
-  map.load(data.data)
-  RpgCommonMap.buffer.set(data.id, map)
-}
-
-async function movePlayers(data) {
-  objectsByMap = {}
-  const ret = {}
-  for (let object of data) {
-    gameEngine.world.addObject(object.id, object)
-    const { player } = await gameEngine.processInput(object.id)
-    if (player) {
-      ret[player.id] = {
-        position: {
-          x: player.position.x,
-          y: player.position.y,
-          z: player.position.z
-        },
-        direction: player.direction
-      }
-    }  
-  }
-  return ret
-}
-  
-workerpool.worker({
-  loadMap,
-  movePlayers
-});