@dcl/sdk 7.3.31 → 7.3.32-7170667436.commit-11a2181

package/src/network-transport/client.ts

@@ -1,77 +0,0 @@
-import { craftMessage, createNetworkManager, encodeString, syncFilter } from './utils'
-import { Transport, engine } from '@dcl/ecs'
-import { getHeaders } from '~system/SignedFetch'
-
-import { MessageType, NetworkManager, Socket } from './types'
-
-export type ClientTransportConfig = {
-  serverUrl: string
-}
-
-export async function createClientTransport({ serverUrl }: ClientTransportConfig): Promise<NetworkManager> {
-  const messagesToProcess: Uint8Array[] = []
-
-  return new Promise<NetworkManager>((resolve, reject) => {
-    try {
-      const ws = new WebSocket(serverUrl) as Socket
-      ws.binaryType = 'arraybuffer'
-
-      ws.onopen = async () => {
-        console.log('WS Server Sync connected')
-        const { headers } = await getHeaders({ url: serverUrl, init: { headers: {} } })
-        ws.send(craftMessage(MessageType.Auth, encodeString(JSON.stringify(headers))))
-
-        const transport: Transport = {
-          filter: syncFilter,
-          send: async (message: Uint8Array) => {
-            if (ws.readyState === WebSocket.OPEN) {
-              ws.send(craftMessage(MessageType.Crdt, message))
-            }
-            if (messagesToProcess && messagesToProcess.length) {
-              if (transport.onmessage) {
-                for (const byteArray of messagesToProcess) {
-                  transport.onmessage(byteArray)
-                }
-              }
-            }
-            messagesToProcess.length = 0
-          }
-        }
-        engine.addTransport(transport)
-      }
-
-      ws.onmessage = (event) => {
-        if (event.data.byteLength) {
-          let offset = 0
-          const r = new Uint8Array(event.data)
-          const view = new DataView(r.buffer)
-          const msgType = view.getUint8(offset)
-          offset += 1
-
-          if (msgType === MessageType.Crdt) {
-            messagesToProcess.push(r.subarray(offset))
-          } else if (msgType === MessageType.Init) {
-            const start = view.getUint32(offset)
-            offset += 4
-            const size = view.getUint32(offset)
-            offset += 4
-            const localEntitiesReserved = view.getUint32(offset)
-            offset += 4
-            resolve(createNetworkManager(localEntitiesReserved, [start, start + size]))
-            messagesToProcess.push(r.subarray(offset))
-          }
-        }
-      }
-
-      ws.onerror = (e) => {
-        console.error(e)
-        reject(e)
-      }
-      ws.onclose = () => {
-        reject(new Error('socket closed'))
-      }
-    } catch (err) {
-      reject(err)
-    }
-  })
-}

package/src/network-transport/index.ts

@@ -1,45 +0,0 @@
-import { isServer } from '~system/EngineApi'
-
-import { NetworkManager, ServerTransportConfig } from './types'
-import { Schemas, engine } from '@dcl/ecs'
-import { createServerTransport } from './server'
-import { ClientTransportConfig, createClientTransport } from './client'
-
-export { NetworkManager } from './types'
-
-export type NetworkTransportConfig = ClientTransportConfig & Partial<ServerTransportConfig>
-
-export let connected = false
-
-const DEFAULT_NETWORK_ENTITY_LIMIT_SERVER = 512
-const DEFAULT_NETWORK_ENTITY_LIMIT_CLIENT = 100
-const DEFAULT_RESERVED_LOCAL_ENTITIES = 2560
-
-export let reservedLocalEntities: number
-/**
- * @alpha
- * Connect to CRDT server
- */
-export async function createNetworkManager(config: NetworkTransportConfig): Promise<NetworkManager> {
-  if (connected) {
-    throw new Error('Transport is already created')
-  }
-
-  const serverConfig = {
-    networkEntitiesLimit: config.networkEntitiesLimit ?? {
-      serverLimit: DEFAULT_NETWORK_ENTITY_LIMIT_SERVER,
-      clientLimit: DEFAULT_NETWORK_ENTITY_LIMIT_CLIENT
-    },
-    reservedLocalEntities: config.reservedLocalEntities || DEFAULT_RESERVED_LOCAL_ENTITIES
-  }
-  reservedLocalEntities = serverConfig.reservedLocalEntities
-
-  const networkFactory =
-    isServer && (await isServer({})).isServer ? createServerTransport(serverConfig) : createClientTransport(config)
-  connected = true
-  return networkFactory
-}
-
-export const PlayersConnected = engine.defineComponent('chore:network:players', {
-  usersId: Schemas.Array(Schemas.String)
-})

package/src/network-transport/server.ts

@@ -1,66 +0,0 @@
-import { engine, SyncComponents, Transport } from '@dcl/ecs'
-import { engineToCrdt } from './state'
-import { syncFilter, createNetworkManager } from './utils'
-import { NetworkManager, ServerTransportConfig } from './types'
-import { PlayersConnected } from '.'
-
-export async function createServerTransport(config: ServerTransportConfig): Promise<NetworkManager> {
-  const connectedClients = new Set<string>()
-  engine.addTransport({
-    send: async (message) => {
-      if (message.byteLength) {
-        globalThis.updateCRDTState(engineToCrdt(engine))
-      }
-    },
-    filter: syncFilter
-  })
-
-  let time = 0
-  function initialCrdtState(dt: number) {
-    time += dt
-    if (time >= 1) {
-      globalThis.updateCRDTState(engineToCrdt(engine))
-      engine.removeSystem(initialCrdtState)
-    }
-  }
-
-  engine.addSystem(initialCrdtState)
-  globalThis.registerScene(config, (event) => {
-    const { type } = event
-    if (type === 'open') {
-      const { clientId, client } = event
-      const transport: Transport = {
-        filter: (message) => {
-          if (!connectedClients.has(clientId)) return false
-          return syncFilter(message)
-        },
-        send: async (message) => {
-          if (message.byteLength > 0) {
-            await client.sendCrdtMessage(message)
-          }
-
-          if (transport.onmessage) {
-            const messages = client.getMessages()
-            for (const byteArray of messages) {
-              transport.onmessage(byteArray)
-            }
-          }
-        }
-      }
-
-      engine.addTransport(transport)
-      connectedClients.add(event.clientId)
-    } else if (type === 'close') {
-      connectedClients.delete(event.clientId)
-    }
-    PlayersConnected.createOrReplace(players, { usersId: [...connectedClients.values()].map(String) })
-  })
-
-  const networkEntityFactory = createNetworkManager(config.reservedLocalEntities, [
-    config.reservedLocalEntities,
-    config.reservedLocalEntities + config.networkEntitiesLimit.serverLimit
-  ])
-  const players = networkEntityFactory.addEntity()
-  SyncComponents.create(players, { componentIds: [PlayersConnected.componentId] })
-  return networkEntityFactory
-}

package/src/network-transport/state.ts

@@ -1,13 +0,0 @@
-import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
-import { IEngine, SyncComponents } from '@dcl/ecs'
-
-export function engineToCrdt(engine: IEngine): Uint8Array {
-  const crdtBuffer = new ReadWriteByteBuffer()
-  const syncEntities = new Set(Array.from(engine.getEntitiesWith(SyncComponents)).map(($) => $[0]))
-
-  for (const itComponentDefinition of engine.componentsIter()) {
-    itComponentDefinition.dumpCrdtStateToBuffer(crdtBuffer, (entity) => syncEntities.has(entity))
-  }
-
-  return crdtBuffer.toBinary()
-}

package/src/network-transport/types.ts

@@ -1,41 +0,0 @@
-import { Entity, engine } from '@dcl/ecs'
-
-export type Socket = WebSocket & {
-  binaryType: string
-  send(data: string | Uint8Array): void
-}
-
-export type NetworkManager = {
-  addEntity(theEngine: typeof engine): Entity
-}
-
-export enum MessageType {
-  Auth = 1,
-  Init = 2,
-  Crdt = 3
-}
-
-export type ServerTransportConfig = {
-  reservedLocalEntities: number
-  networkEntitiesLimit: {
-    serverLimit: number
-    clientLimit: number
-  }
-}
-
-declare global {
-  type ClientEvent =
-    | {
-        type: 'open'
-        clientId: string
-        client: {
-          sendCrdtMessage(message: Uint8Array): Promise<void>
-          getMessages(): Uint8Array[]
-        }
-      }
-    | { type: 'close'; clientId: string }
-  // eslint-disable-next-line no-var
-  var updateCRDTState: (crdt: Uint8Array) => void
-  // eslint-disable-next-line no-var
-  var registerScene: (serverConfig: ServerTransportConfig, fn: (event: ClientEvent) => void) => void
-}

package/src/network-transport/utils.ts

@@ -1,67 +0,0 @@
-import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
-import {
-  engine,
-  TransportMessage,
-  PointerEventsResult,
-  RESERVED_STATIC_ENTITIES,
-  SyncComponents,
-  CrdtMessageType,
-  EntityUtils,
-  GltfContainerLoadingState
-} from '@dcl/ecs'
-import { MessageType } from './types'
-import { connected, reservedLocalEntities } from '.'
-
-export function encodeString(s: string): Uint8Array {
-  const buffer = new ReadWriteByteBuffer()
-  buffer.writeUtf8String(s)
-  return buffer.readBuffer()
-}
-
-export function craftMessage(msgType: MessageType, payload: Uint8Array): Uint8Array {
-  const msg = new Uint8Array(payload.byteLength + 1)
-  msg.set([msgType])
-  msg.set(payload, 1)
-  return msg
-}
-
-export function createNetworkManager(reservedLocalEntities: number, range: [number, number]) {
-  return engine.addNetworkManager(reservedLocalEntities, range)
-}
-
-export function syncFilter(message: Omit<TransportMessage, 'messageBuffer'>) {
-  if (!connected) return false
-  const componentId = (message as any).componentId
-  if ([PointerEventsResult.componentId, GltfContainerLoadingState.componentId].includes(componentId)) {
-    return false
-  }
-
-  const [entityId] = EntityUtils.fromEntityId(message.entityId)
-  // filter messages from reserved entities.
-  if (entityId < RESERVED_STATIC_ENTITIES) {
-    return false
-  }
-
-  if (entityId < reservedLocalEntities) {
-    return false
-  }
-
-  // Network Entity Always
-  if (message.type === CrdtMessageType.DELETE_ENTITY) {
-    return true
-  }
-
-  // TBD: First component
-  if ((message as any).timestamp <= 1) {
-    return true
-  }
-
-  const sync = SyncComponents.getOrNull(message.entityId)
-  if (!sync) return false
-
-  if ((message as any).componentId && sync.componentIds.includes((message as any).componentId)) {
-    return true
-  }
-
-  return false
-}