@dcl/playground-assets 7.0.5 → 7.0.6-3713220614.commit-d02ef9f

package/dist/index.js

@@ -12828,7 +12828,8 @@
     		        }
     		        // Race condition, same timestamp diff data.
     		        function compareData(current, data) {
-    		            return current > data;
+    		            // Null value wins
+    		            return !current || current > data;
     		        }
     		        if (compareData(current.data, data)) {
     		            return {
@@ -13130,13 +13131,14 @@
      */
     var WireMessage;
     (function (WireMessage) {
+        let Enum;
         (function (Enum) {
             Enum[Enum["RESERVED"] = 0] = "RESERVED";
             // Component Operation
             Enum[Enum["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
             Enum[Enum["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
             Enum[Enum["MAX_MESSAGE_TYPE"] = 3] = "MAX_MESSAGE_TYPE";
-        })(WireMessage.Enum || (WireMessage.Enum = {}));
+        })(Enum = WireMessage.Enum || (WireMessage.Enum = {}));
         WireMessage.HEADER_LENGTH = 8;
         /**
          * Validate if the message incoming is completed
@@ -13164,6 +13166,10 @@
             };
         }
         WireMessage.readHeader = readHeader;
+        function getType(component, entity) {
+            return component.has(entity) ? Enum.PUT_COMPONENT : Enum.DELETE_COMPONENT;
+        }
+        WireMessage.getType = getType;
     })(WireMessage || (WireMessage = {}));
     var WireMessage$1 = WireMessage;
 
@@ -13221,14 +13227,15 @@
         // Messages that we received at transport.onMessage waiting to be processed
         const receivedMessages = [];
         // Messages already processed by the engine but that we need to broadcast to other transports.
-        const transportMessages = [];
-        // Map of entities already processed at least once
+        const broadcastMessages = [];
+        // Messages receieved by a transport that were outdated. We need to correct them
+        const outdatedMessages = [];
         /**
          *
-         * @param transportType tranport id to identiy messages
+         * @param transportId tranport id to identiy messages
          * @returns a function to process received messages
          */
-        function parseChunkMessage(transportType) {
+        function parseChunkMessage(transportId) {
             /**
              * Receives a chunk of binary messages and stores all the valid
              * Component Operation Messages at messages queue
@@ -13248,7 +13255,7 @@
                         componentId,
                         data,
                         timestamp,
-                        transportType,
+                        transportId,
                         messageBuffer: buffer
                             .buffer()
                             .subarray(offset, buffer.currentReadOffset())
@@ -13262,93 +13269,117 @@
          * @returns messages recieved by the transport to process on the next tick
          */
         function getMessages(value) {
-            const messagesToProcess = Array.from(value);
-            value.length = 0;
+            const messagesToProcess = value.splice(0, value.length);
             return messagesToProcess;
         }
         /**
          * This fn will be called on every tick.
          * Process all the messages queue received by the transport
          */
-        function receiveMessages() {
+        async function receiveMessages() {
             const messagesToProcess = getMessages(receivedMessages);
-            for (const transport of transports) {
-                const buffer = createByteBuffer();
-                for (const message of messagesToProcess) {
-                    const { data, timestamp, componentId, entity, type } = message;
-                    const crdtMessage = {
-                        key1: entity,
-                        key2: componentId,
-                        data: data || null,
-                        timestamp: timestamp
-                    };
-                    const component = engine.getComponentOrNull(componentId);
-                    const current = crdtClient.processMessage(crdtMessage);
-                    /* istanbul ignore next */
-                    if (!component)
-                        // TODO: TEST
-                        continue;
-                    // CRDT outdated message. Resend this message through the wire
-                    if (crdtMessage !== current) {
-                        const type = component.has(entity)
-                            ? WireMessage$1.Enum.PUT_COMPONENT
-                            : WireMessage$1.Enum.DELETE_COMPONENT;
-                        ComponentOperation.write(type, entity, current.timestamp, component, buffer);
+            const bufferForOutdated = createByteBuffer();
+            for (const message of messagesToProcess) {
+                const { data, timestamp, componentId, entity, type } = message;
+                const crdtMessage = {
+                    key1: entity,
+                    key2: componentId,
+                    data: data || null,
+                    timestamp: timestamp
+                };
+                const component = engine.getComponentOrNull(componentId);
+                if (component?.isDirty(entity)) {
+                    crdtClient.createEvent(entity, component._id, component.toBinaryOrNull(entity)?.toBinary() || null);
+                }
+                const current = crdtClient.processMessage(crdtMessage);
+                if (!component) {
+                    continue;
+                }
+                // CRDT outdated message. Resend this message to the transport
+                // To do this we add this message to a queue that will be processed at the end of the update tick
+                if (crdtMessage !== current) {
+                    const offset = bufferForOutdated.currentWriteOffset();
+                    const type = WireMessage$1.getType(component, entity);
+                    const ts = current.timestamp;
+                    ComponentOperation.write(type, entity, ts, component, bufferForOutdated);
+                    outdatedMessages.push({
+                        ...message,
+                        timestamp: current.timestamp,
+                        messageBuffer: bufferForOutdated
+                            .buffer()
+                            .subarray(offset, bufferForOutdated.currentWriteOffset())
+                    });
+                }
+                else {
+                    // Add message to transport queue to be processed by others transports
+                    broadcastMessages.push(message);
+                    // Process CRDT Message
+                    if (type === WireMessage$1.Enum.DELETE_COMPONENT) {
+                        component.deleteFrom(entity, false);
                     }
                     else {
-                        // Process CRDT Message
-                        if (type === WireMessage$1.Enum.DELETE_COMPONENT) {
-                            component.deleteFrom(entity);
-                        }
-                        else {
-                            const opts = {
-                                reading: { buffer: message.data, currentOffset: 0 }
-                            };
-                            const bb = createByteBuffer(opts);
-                            // Update engine component
-                            component.upsertFromBinary(message.entity, bb);
-                            component.clearDirty();
-                        }
-                        // Add message to transport queue to be processed by others transports
-                        transportMessages.push(message);
+                        const opts = {
+                            reading: { buffer: message.data, currentOffset: 0 }
+                        };
+                        const data = createByteBuffer(opts);
+                        component.upsertFromBinary(message.entity, data, false);
+                    }
+                }
+            }
+        }
+        function getDirtyMap() {
+            const dirtySet = new Map();
+            for (const [componentId, definition] of engine.componentsDefinition) {
+                for (const entity of definition.dirtyIterator()) {
+                    if (!dirtySet.has(entity)) {
+                        dirtySet.set(entity, new Set());
                     }
+                    dirtySet.get(entity).add(componentId);
                 }
-                if (buffer.size()) {
-                    transport.send(buffer.toBinary());
+            }
+            return dirtySet;
+        }
+        /**
+         * Updates CRDT state of the current engine dirty components
+         */
+        function updateState() {
+            const dirtyEntities = getDirtyMap();
+            for (const [entity, componentsId] of getDirtyMap()) {
+                for (const componentId of componentsId) {
+                    const component = engine.getComponent(componentId);
+                    const componentValue = component.toBinaryOrNull(entity)?.toBinary() ?? null;
+                    crdtClient.createEvent(entity, componentId, componentValue);
                 }
             }
+            return dirtyEntities;
         }
         /**
          * Iterates the dirty map and generates crdt messages to be send
-         * @param dirtyMap a map of { entities: [componentId] }
          */
-        function createMessages(dirtyMap) {
+        async function sendMessages(dirtyEntities) {
             // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
-            const crdtMessages = getMessages(transportMessages);
+            const crdtMessages = getMessages(broadcastMessages);
+            const outdatedMessagesBkp = getMessages(outdatedMessages);
             const buffer = createByteBuffer();
-            for (const [entity, componentsId] of dirtyMap) {
+            for (const [entity, componentsId] of dirtyEntities) {
                 for (const componentId of componentsId) {
-                    const component = engine.getComponentOrNull(componentId);
-                    /* istanbul ignore next */
-                    if (!component)
-                        // TODO: test coverage
-                        continue;
-                    const entityComponent = component.has(entity)
-                        ? component.toBinary(entity).toBinary()
-                        : null;
-                    const event = crdtClient.createEvent(entity, componentId, entityComponent);
+                    // Component will be always defined here since dirtyMap its an iterator of engine.componentsDefinition
+                    const component = engine.getComponent(componentId);
+                    const { timestamp } = crdtClient
+                        .getState()
+                        .get(entity)
+                        .get(componentId);
                     const offset = buffer.currentWriteOffset();
-                    const type = component.has(entity)
-                        ? WireMessage$1.Enum.PUT_COMPONENT
-                        : WireMessage$1.Enum.DELETE_COMPONENT;
+                    const type = WireMessage$1.getType(component, entity);
                     const transportMessage = {
                         type,
                         componentId,
                         entity,
-                        timestamp: event.timestamp
+                        timestamp
                     };
+                    // Avoid creating messages if there is no transport that will handle it
                     if (transports.some((t) => t.filter(transportMessage))) {
-                        ComponentOperation.write(type, entity, event.timestamp, component, buffer);
+                        ComponentOperation.write(type, entity, timestamp, component, buffer);
                         crdtMessages.push({
                             ...transportMessage,
                             messageBuffer: buffer
@@ -13358,33 +13389,56 @@
                     }
                 }
             }
-            // Send messages to transports
+            // Send CRDT messages to transports
             const transportBuffer = createByteBuffer();
-            for (const transport of transports) {
+            for (const index in transports) {
+                const transportIndex = Number(index);
+                const transport = transports[transportIndex];
                 transportBuffer.resetBuffer();
-                for (const message of crdtMessages) {
-                    if (transport.filter(message)) {
+                // First we need to send all the messages that were outdated from a transport
+                // So we can fix their crdt state
+                for (const message of outdatedMessagesBkp) {
+                    if (message.transportId === transportIndex &&
+                        // Avoid sending multiple messages for the same entity-componentId
+                        !crdtMessages.find((m) => m.entity === message.entity &&
+                            m.componentId === message.componentId)) {
                         transportBuffer.writeBuffer(message.messageBuffer, false);
                     }
                 }
-                if (transportBuffer.size()) {
-                    transport.send(transportBuffer.toBinary());
-                }
-                else {
-                    transport.send(new Uint8Array([]));
+                // Then we send all the new crdtMessages that the transport needs to process
+                for (const message of crdtMessages) {
+                    if (message.transportId !== transportIndex &&
+                        transport.filter(message)) {
+                        transportBuffer.writeBuffer(message.messageBuffer, false);
+                    }
                 }
+                const message = transportBuffer.size()
+                    ? transportBuffer.toBinary()
+                    : new Uint8Array([]);
+                await transport.send(message);
             }
         }
+        /**
+         * @public
+         * Add a transport to the crdt system
+         */
         function addTransport(transport) {
-            transports.push(transport);
-            transport.onmessage = parseChunkMessage(transport.type);
-            // TODO: pull messages from transport
-            // TODO: send entities to transport
+            const id = transports.push(transport) - 1;
+            transport.onmessage = parseChunkMessage(id);
+        }
+        /**
+         * @public
+         * @returns returns the crdt state
+         */
+        function getCrdt() {
+            return crdtClient.getState();
         }
         return {
-            createMessages,
+            getCrdt,
+            sendMessages,
             receiveMessages,
-            addTransport
+            addTransport,
+            updateState
         };
     }
 
@@ -13431,10 +13485,15 @@
             has(entity) {
                 return data.has(entity);
             },
-            deleteFrom(entity) {
+            deleteFrom(entity, markAsDirty = true) {
                 const component = data.get(entity);
                 data.delete(entity);
-                dirtyIterator.add(entity);
+                if (markAsDirty) {
+                    dirtyIterator.add(entity);
+                }
+                else {
+                    dirtyIterator.delete(entity);
+                }
                 return component || null;
             },
             getOrNull(entity) {
@@ -13498,6 +13557,15 @@
                 spec.serialize(component, writeBuffer);
                 return writeBuffer;
             },
+            toBinaryOrNull(entity) {
+                const component = data.get(entity);
+                if (!component) {
+                    return null;
+                }
+                const writeBuffer = createByteBuffer();
+                spec.serialize(component, writeBuffer);
+                return writeBuffer;
+            },
             writeToByteBuffer(entity, buffer) {
                 const component = data.get(entity);
                 if (!component) {
@@ -13505,19 +13573,27 @@
                 }
                 spec.serialize(component, buffer);
             },
-            updateFromBinary(entity, buffer) {
+            updateFromBinary(entity, buffer, markAsDirty = true) {
                 const component = data.get(entity);
                 if (!component) {
                     throw new Error(`[updateFromBinary] Component ${componentId} for ${entity} not found`);
                 }
-                return this.upsertFromBinary(entity, buffer);
+                return this.upsertFromBinary(entity, buffer, markAsDirty);
             },
-            upsertFromBinary(entity, buffer) {
+            upsertFromBinary(entity, buffer, markAsDirty = true) {
                 const newValue = spec.deserialize(buffer);
                 data.set(entity, newValue);
-                dirtyIterator.add(entity);
+                if (markAsDirty) {
+                    dirtyIterator.add(entity);
+                }
+                else {
+                    dirtyIterator.delete(entity);
+                }
                 return newValue;
             },
+            deserialize(buffer) {
+                return spec.deserialize(buffer);
+            },
             clearDirty() {
                 dirtyIterator.clear();
             }
@@ -13855,6 +13931,14 @@
             }
             return entityContainer.removeEntity(entity);
         }
+        function registerCustomComponent(component, componentId) {
+            const prev = componentsDefinition.get(componentId);
+            if (prev) {
+                throw new Error(`Component number ${componentId} was already registered.`);
+            }
+            componentsDefinition.set(componentId, component);
+            return component;
+        }
         function defineComponentFromSchema(spec, componentId, constructorDefault) {
             const prev = componentsDefinition.get(componentId);
             if (prev) {
@@ -13906,6 +13990,24 @@
         function removeComponentDefinition(componentId) {
             componentsDefinition.delete(componentId);
         }
+        const Transform = Transform$1({ defineComponentFromSchema });
+        function* getTreeEntityArray(firstEntity, proccesedEntities) {
+            // This avoid infinite loop when there is a cyclic parenting
+            if (proccesedEntities.find((value) => firstEntity === value))
+                return;
+            proccesedEntities.push(firstEntity);
+            for (const [entity, value] of getEntitiesWith(Transform)) {
+                if (value.parent === firstEntity) {
+                    yield* getTreeEntityArray(entity, proccesedEntities);
+                }
+            }
+            yield firstEntity;
+        }
+        function removeEntityWithChildren(firstEntity) {
+            for (const entity of getTreeEntityArray(firstEntity, [])) {
+                removeEntity(entity);
+            }
+        }
         return {
             entityExists,
             componentsDefinition,
@@ -13919,7 +14021,9 @@
             getEntitiesWith,
             getComponent,
             getComponentOrNull,
-            removeComponentDefinition
+            removeComponentDefinition,
+            removeEntityWithChildren,
+            registerCustomComponent
         };
     }
     /**
@@ -13928,55 +14032,27 @@
     function Engine() {
         const engine = preEngine();
         const crdtSystem = crdtSceneSystem(engine);
-        function update(dt) {
-            crdtSystem.receiveMessages();
+        async function update(dt) {
+            await crdtSystem.receiveMessages();
             for (const system of engine.getSystems()) {
                 const ret = system.fn(dt);
                 checkNotThenable(ret, `A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
             }
-            // TODO: Perf tip
-            // Should we add some dirtyIteratorSet at engine level so we dont have
-            // to iterate all the component definitions to get the dirty ones ?
-            const dirtySet = new Map();
-            for (const [componentId, definition] of engine.componentsDefinition) {
-                for (const entity of definition.dirtyIterator()) {
-                    if (!dirtySet.has(entity)) {
-                        dirtySet.set(entity, new Set());
-                    }
-                    dirtySet.get(entity).add(componentId);
-                }
-            }
-            crdtSystem.createMessages(dirtySet);
+            const dirtyEntities = crdtSystem.updateState();
+            await crdtSystem.sendMessages(dirtyEntities);
             for (const [_componentId, definition] of engine.componentsDefinition) {
                 definition.clearDirty();
             }
         }
-        const Transform = Transform$1(engine);
-        function* getTreeEntityArray(firstEntity, proccesedEntities) {
-            // This avoid infinite loop when there is a cyclic parenting
-            if (proccesedEntities.find((value) => firstEntity === value))
-                return;
-            proccesedEntities.push(firstEntity);
-            for (const [entity, value] of engine.getEntitiesWith(Transform)) {
-                if (value.parent === firstEntity) {
-                    yield* getTreeEntityArray(entity, proccesedEntities);
-                }
-            }
-            yield firstEntity;
-        }
-        function removeEntityWithChildren(firstEntity) {
-            for (const entity of getTreeEntityArray(firstEntity, [])) {
-                engine.removeEntity(entity);
-            }
-        }
         return {
             addEntity: engine.addEntity,
             removeEntity: engine.removeEntity,
-            removeEntityWithChildren,
+            removeEntityWithChildren: engine.removeEntityWithChildren,
             addSystem: engine.addSystem,
             removeSystem: engine.removeSystem,
             defineComponent: engine.defineComponent,
             defineComponentFromSchema: engine.defineComponentFromSchema,
+            registerCustomComponent: engine.registerCustomComponent,
             getEntitiesWith: engine.getEntitiesWith,
             getComponent: engine.getComponent,
             getComponentOrNull: engine.getComponentOrNull,
@@ -13986,7 +14062,9 @@
             PlayerEntity: 1,
             CameraEntity: 2,
             entityExists: engine.entityExists,
-            addTransport: crdtSystem.addTransport
+            addTransport: crdtSystem.addTransport,
+            getCrdtState: crdtSystem.getCrdt,
+            componentsDefinition: engine.componentsDefinition
         };
     }
 
@@ -40393,19 +40471,17 @@
                 }
             }
         }
-        const type = 'renderer';
         const rendererTransport = {
-            type,
-            send(message) {
-                sendToRenderer(message).catch((error) => {
+            async send(message) {
+                try {
+                    await sendToRenderer(message);
+                }
+                catch (error) {
                     console.error(error);
                     debugger;
-                });
+                }
             },
             filter(message) {
-                if (message.transportType === type) {
-                    return false;
-                }
                 if (!componentIds.includes(message.componentId)) {
                     return false;
                 }
@@ -40418,7 +40494,7 @@
     engine.addTransport(createRendererTransport({ crdtSendToRenderer: EngineApi.crdtSendToRenderer }));
     setSubscribeFunction(EngineApi.subscribe);
     async function onUpdate(deltaTime) {
-        engine.update(deltaTime);
+        await engine.update(deltaTime);
         await pollEvents(EngineApi.sendBatch);
     }