@dcl/ecs 7.3.31 → 7.3.32

package/dist/serialization/crdt/types.d.ts

@@ -8,7 +8,10 @@ export declare enum CrdtMessageType {
     DELETE_COMPONENT = 2,
     DELETE_ENTITY = 3,
     APPEND_VALUE = 4,
-    MAX_MESSAGE_TYPE = 5
+    PUT_COMPONENT_NETWORK = 5,
+    DELETE_COMPONENT_NETWORK = 6,
+    DELETE_ENTITY_NETWORK = 7,
+    MAX_MESSAGE_TYPE = 8
 }
 /**
  * Min length = 8 bytes
@@ -41,6 +44,10 @@ export type PutComponentMessageBody = {
     timestamp: number;
     data: Uint8Array;
 };
+export type PutNetworkComponentMessageBody = Omit<PutComponentMessageBody, 'type'> & {
+    type: CrdtMessageType.PUT_COMPONENT_NETWORK;
+    networkId: number;
+};
 /**
  * Min. length = header (8 bytes) + 16 bytes = 24 bytes
  *
@@ -69,6 +76,20 @@ export type DeleteComponentMessageBody = {
     componentId: number;
     timestamp: number;
 };
+/**
+ * @param entity - Uint32 number of the entity
+ * @param componentId - Uint32 number of id
+ * @param timestamp - Uint32 Lamport timestamp
+ * @param networkId - Uint32 user network id
+ * @public
+ */
+export type DeleteComponentNetworkMessageBody = {
+    type: CrdtMessageType.DELETE_COMPONENT_NETWORK;
+    entityId: Entity;
+    componentId: number;
+    timestamp: number;
+    networkId: number;
+};
 /**
  * @param entity - uint32 number of the entity
  * @public
@@ -77,6 +98,14 @@ export type DeleteEntityMessageBody = {
     type: CrdtMessageType.DELETE_ENTITY;
     entityId: Entity;
 };
+/**
+ * @public
+ */
+export type DeleteEntityNetworkMessageBody = {
+    type: CrdtMessageType.DELETE_ENTITY_NETWORK;
+    entityId: Entity;
+    networkId: number;
+};
 /**
  * @public
  */
@@ -85,10 +114,18 @@ export type AppendValueMessage = CrdtMessageHeader & AppendValueMessageBody;
  * @public
  */
 export type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;
+/**
+ * @public
+ */
+export type PutNetworkComponentMessage = CrdtMessageHeader & PutNetworkComponentMessageBody;
 /**
  * @public
  */
 export type DeleteComponentMessage = CrdtMessageHeader & DeleteComponentMessageBody;
+/**
+ * @public
+ */
+export type DeleteComponentNetworkMessage = CrdtMessageHeader & DeleteComponentNetworkMessageBody;
 /**
  * @public
  */
@@ -96,11 +133,19 @@ export type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;
 /**
  * @public
  */
-export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage | AppendValueMessage;
+export type DeleteEntityNetworkMessage = CrdtMessageHeader & DeleteEntityNetworkMessageBody;
+/**
+ * @public
+ */
+export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | AppendValueMessage | DeleteEntityMessage | PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage;
+/**
+ * @public
+ */
+export type CrdtNetworkMessageBody = PutNetworkComponentMessageBody | DeleteComponentNetworkMessageBody | DeleteEntityNetworkMessageBody;
 /**
  * @public
  */
-export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody;
+export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody | CrdtNetworkMessageBody;
 export declare enum ProcessMessageResultType {
     /**
      * Typical message and new state set.

package/dist/serialization/crdt/types.js

@@ -9,7 +9,11 @@ export var CrdtMessageType;
     CrdtMessageType[CrdtMessageType["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
     CrdtMessageType[CrdtMessageType["DELETE_ENTITY"] = 3] = "DELETE_ENTITY";
     CrdtMessageType[CrdtMessageType["APPEND_VALUE"] = 4] = "APPEND_VALUE";
-    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 5] = "MAX_MESSAGE_TYPE";
+    // Network operations
+    CrdtMessageType[CrdtMessageType["PUT_COMPONENT_NETWORK"] = 5] = "PUT_COMPONENT_NETWORK";
+    CrdtMessageType[CrdtMessageType["DELETE_COMPONENT_NETWORK"] = 6] = "DELETE_COMPONENT_NETWORK";
+    CrdtMessageType[CrdtMessageType["DELETE_ENTITY_NETWORK"] = 7] = "DELETE_ENTITY_NETWORK";
+    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 8] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
 /**
  * @public

package/dist/systems/crdt/index.js

@@ -1,21 +1,26 @@
 import { EntityState } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
-import { AppendValueOperation, CrdtMessageProtocol } from '../../serialization/crdt';
+import { AppendValueOperation, CrdtMessageProtocol, DeleteComponentNetwork, DeleteEntityNetwork } from '../../serialization/crdt';
 import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
 import { DeleteEntity } from '../../serialization/crdt/deleteEntity';
 import { PutComponentOperation } from '../../serialization/crdt/putComponent';
 import { CrdtMessageType } from '../../serialization/crdt/types';
+import { PutNetworkComponentOperation } from '../../serialization/crdt/network/putComponentNetwork';
+import { NetworkEntity as defineNetworkEntity, NetworkParent as defineNetworkParent, Transform as defineTransform } from '../../components';
+import * as networkUtils from '../../serialization/crdt/network/utils';
 /**
  * @internal
  */
 export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
+    // Components that we used on this system
+    const NetworkEntity = defineNetworkEntity(engine);
+    const NetworkParent = defineNetworkParent(engine);
+    const Transform = defineTransform(engine);
     // 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 broadcastMessages = [];
-    // Messages receieved by a transport that were outdated. We need to correct them
-    const outdatedMessages = [];
     /**
      *
      * @param transportId tranport id to identiy messages
@@ -32,45 +37,41 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             let header;
             while ((header = CrdtMessageProtocol.getHeader(buffer))) {
                 const offset = buffer.currentReadOffset();
+                let message = undefined;
                 if (header.type === CrdtMessageType.DELETE_COMPONENT) {
-                    const message = DeleteComponent.read(buffer);
-                    receivedMessages.push({
-                        ...message,
-                        transportId,
-                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
-                    });
+                    message = DeleteComponent.read(buffer);
+                }
+                else if (header.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+                    message = DeleteComponentNetwork.read(buffer);
                 }
                 else if (header.type === CrdtMessageType.PUT_COMPONENT) {
-                    const message = PutComponentOperation.read(buffer);
-                    receivedMessages.push({
-                        ...message,
-                        transportId,
-                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
-                    });
+                    message = PutComponentOperation.read(buffer);
+                }
+                else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+                    message = PutNetworkComponentOperation.read(buffer);
                 }
                 else if (header.type === CrdtMessageType.DELETE_ENTITY) {
-                    const message = DeleteEntity.read(buffer);
-                    receivedMessages.push({
-                        ...message,
-                        transportId,
-                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
-                    });
+                    message = DeleteEntity.read(buffer);
+                }
+                else if (header.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+                    message = DeleteEntityNetwork.read(buffer);
                 }
                 else if (header.type === CrdtMessageType.APPEND_VALUE) {
-                    const message = AppendValueOperation.read(buffer);
-                    receivedMessages.push({
-                        ...message,
-                        transportId,
-                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
-                    });
+                    message = AppendValueOperation.read(buffer);
                     // Unknown message, we skip it
                 }
                 else {
                     // consume the message
                     buffer.incrementReadOffset(header.length);
                 }
+                if (message) {
+                    receivedMessages.push({
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+                    });
+                }
             }
-            // TODO: do something if buffler.len>0
         };
     }
     /**
@@ -81,46 +82,61 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         const messagesToProcess = value.splice(0, value.length);
         return messagesToProcess;
     }
+    /**
+     * Find the local entityId associated to the network component message.
+     * It's a mapping Network -> to Local
+     * If it's not a network message, return the entityId received by the message
+     */
+    function findNetworkId(msg) {
+        const hasNetworkId = 'networkId' in msg;
+        if (hasNetworkId) {
+            for (const [entityId, network] of engine.getEntitiesWith(NetworkEntity)) {
+                if (network.networkId === msg.networkId && network.entityId === msg.entityId) {
+                    return { entityId, network };
+                }
+            }
+        }
+        return { entityId: msg.entityId };
+    }
     /**
      * This fn will be called on every tick.
      * Process all the messages queue received by the transport
      */
     async function receiveMessages() {
         const messagesToProcess = getMessages(receivedMessages);
-        const bufferForOutdated = new ReadWriteByteBuffer();
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
-            if (msg.type === CrdtMessageType.DELETE_ENTITY) {
-                entitiesShouldBeCleaned.push(msg.entityId);
+            let { entityId, network } = findNetworkId(msg);
+            // We receive a new Entity. Create the localEntity and map it to the NetworkEntity component
+            if (networkUtils.isNetworkMessage(msg) && !network) {
+                entityId = engine.addEntity();
+                network = { entityId: msg.entityId, networkId: msg.networkId };
+                NetworkEntity.createOrReplace(entityId, network);
+            }
+            if (msg.type === CrdtMessageType.DELETE_ENTITY || msg.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+                entitiesShouldBeCleaned.push(entityId);
                 broadcastMessages.push(msg);
             }
             else {
-                const entityState = engine.entityContainer.getEntityState(msg.entityId);
+                const entityState = engine.entityContainer.getEntityState(entityId);
                 // Skip updates from removed entityes
                 if (entityState === EntityState.Removed)
                     continue;
                 // Entities with unknown entities should update its entity state
                 if (entityState === EntityState.Unknown) {
-                    engine.entityContainer.updateUsedEntity(msg.entityId);
+                    engine.entityContainer.updateUsedEntity(entityId);
                 }
                 const component = engine.getComponentOrNull(msg.componentId);
                 /* istanbul ignore else */
                 if (component) {
-                    const [conflictMessage, value] = component.updateFromCrdt(msg);
-                    if (conflictMessage) {
-                        const offset = bufferForOutdated.currentWriteOffset();
-                        if (conflictMessage.type === CrdtMessageType.PUT_COMPONENT) {
-                            PutComponentOperation.write(msg.entityId, conflictMessage.timestamp, conflictMessage.componentId, conflictMessage.data, bufferForOutdated);
-                        }
-                        else if (conflictMessage.type === CrdtMessageType.DELETE_COMPONENT) {
-                            DeleteComponent.write(msg.entityId, component.componentId, conflictMessage.timestamp, bufferForOutdated);
-                        }
-                        outdatedMessages.push({
-                            ...msg,
-                            messageBuffer: bufferForOutdated.buffer().subarray(offset, bufferForOutdated.currentWriteOffset())
-                        });
+                    if (msg.type === CrdtMessageType.PUT_COMPONENT &&
+                        component.componentId === Transform.componentId &&
+                        NetworkEntity.has(entityId) &&
+                        NetworkParent.has(entityId)) {
+                        msg.data = networkUtils.fixTransformParent(msg);
                     }
-                    else {
+                    const [conflictMessage, value] = component.updateFromCrdt({ ...msg, entityId });
+                    if (!conflictMessage) {
                         // Add message to transport queue to be processed by others transports
                         broadcastMessages.push(msg);
                         onProcessEntityComponentChange && onProcessEntityComponentChange(msg.entityId, msg.type, component, value);
@@ -134,12 +150,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         }
         // the last stage of the syncrhonization is to delete the entities
         for (const entity of entitiesShouldBeCleaned) {
-            // If we tried to resend outdated message and the entity was deleted before, we avoid sending them.
-            for (let i = outdatedMessages.length - 1; i >= 0; i--) {
-                if (outdatedMessages[i].entityId === entity && outdatedMessages[i].type !== CrdtMessageType.DELETE_ENTITY) {
-                    outdatedMessages.splice(i, 1);
-                }
-            }
             for (const definition of engine.componentsIter()) {
                 // TODO: check this with pato/pravus
                 definition.entityDeleted(entity, true);
@@ -154,7 +164,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     async function sendMessages(entitiesDeletedThisTick) {
         // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
         const crdtMessages = getMessages(broadcastMessages);
-        const outdatedMessagesBkp = getMessages(outdatedMessages);
         const buffer = new ReadWriteByteBuffer();
         for (const component of engine.componentsIter()) {
             for (const message of component.getCrdtUpdates()) {
@@ -199,25 +208,58 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         for (const index in transports) {
             const transportIndex = Number(index);
             const transport = transports[transportIndex];
+            const isRendererTransport = transport.type === 'renderer';
+            const isNetworkTransport = transport.type === 'network';
             transportBuffer.resetBuffer();
-            // 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 &&
-                    // TODO: This is an optimization, the state should converge anyway, whatever the message is sent.
-                    // Avoid sending multiple messages for the same entity-componentId
-                    !crdtMessages.find((m) => m.entityId === message.entityId &&
-                        // TODO: as any, with multiple type of messages, it should have many checks before the check for similar messages
-                        m.componentId &&
-                        m.componentId === message.componentId)) {
-                    transportBuffer.writeBuffer(message.messageBuffer, false);
-                }
-            }
+            const buffer = new ReadWriteByteBuffer();
             // 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);
+                // Avoid echo messages
+                if (message.transportId === transportIndex)
+                    continue;
+                // Redundant message for the transport
+                if (!transport.filter(message))
+                    continue;
+                const { entityId } = findNetworkId(message);
+                const transformNeedsFix = 'componentId' in message &&
+                    message.componentId === Transform.componentId &&
+                    Transform.has(entityId) &&
+                    NetworkParent.has(entityId) &&
+                    NetworkEntity.has(entityId);
+                // If there was a LOCAL change in the transform. Add the parent to that transform
+                if (isRendererTransport && message.type === CrdtMessageType.PUT_COMPONENT && transformNeedsFix) {
+                    const parent = findNetworkId(NetworkParent.get(entityId));
+                    const transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
+                    const offset = buffer.currentWriteOffset();
+                    PutComponentOperation.write(entityId, message.timestamp, message.componentId, transformData, buffer);
+                    transportBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+                    continue;
+                }
+                if (isRendererTransport && networkUtils.isNetworkMessage(message)) {
+                    // If it's the renderer transport and its a NetworkMessage, we need to fix the entityId field and convert it to a known Message.
+                    // PUT_NETWORK_COMPONENT -> PUT_COMPONENT
+                    let transformData = 'data' in message ? message.data : new Uint8Array();
+                    if (transformNeedsFix) {
+                        const parent = findNetworkId(NetworkParent.get(entityId));
+                        transformData = networkUtils.fixTransformParent(message, Transform.get(entityId), parent.entityId);
+                    }
+                    networkUtils.networkMessageToLocal({ ...message, data: transformData }, entityId, buffer, transportBuffer);
+                    // Iterate the next message
+                    continue;
+                }
+                // If its a network transport and its a PUT_COMPONENT that has a NetworkEntity component, we need to send this message
+                // through comms with the EntityID and NetworkID from ther NetworkEntity so everyone can recieve this message and map to their custom entityID.
+                if (isNetworkTransport && !networkUtils.isNetworkMessage(message)) {
+                    const networkData = NetworkEntity.getOrNull(message.entityId);
+                    // If it has networkData convert the message to PUT_NETWORK_COMPONENT.
+                    if (networkData) {
+                        networkUtils.localMessageToNetwork(message, networkData, buffer, transportBuffer);
+                        // Iterate the next message
+                        continue;
+                    }
                 }
+                // Common message
+                transportBuffer.writeBuffer(message.messageBuffer, false);
             }
             const message = transportBuffer.currentWriteOffset() ? transportBuffer.toBinary() : new Uint8Array([]);
             await transport.send(message);

package/dist/systems/crdt/types.d.ts

@@ -1,4 +1,4 @@
-import { CrdtMessageBody } from '../../serialization/crdt/types';
+import { CrdtMessageBody, CrdtNetworkMessageBody } from '../../serialization/crdt/types';
 /**
  * @public
  */
@@ -6,6 +6,13 @@ export type ReceiveMessage = CrdtMessageBody & {
     transportId?: number;
     messageBuffer: Uint8Array;
 };
+/**
+ * @public
+ */
+export type ReceiveNetworkMessage = CrdtNetworkMessageBody & {
+    transportId?: number;
+    messageBuffer: Uint8Array;
+};
 /**
  * @public
  */
@@ -17,4 +24,5 @@ export type Transport = {
     send(message: Uint8Array): Promise<void>;
     onmessage?(message: Uint8Array): void;
     filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
+    type?: string;
 };

package/dist-cjs/components/index.d.ts

@@ -8,6 +8,8 @@ import { TweenComponentDefinitionExtended } from './extended/Tween';
 import { LwwComponentGetter, GSetComponentGetter } from './generated/index.gen';
 import { NameType } from './manual/Name';
 import { ISyncComponentsType } from './manual/SyncComponents';
+import { INetowrkEntityType } from './manual/NetworkEntity';
+import { INetowrkParentType } from './manual/NetworkParent';
 import { TransformComponentExtended } from './manual/Transform';
 export * from './generated/index.gen';
 export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
@@ -25,3 +27,11 @@ export declare const Name: (engine: Pick<IEngine, 'defineComponent'>) => LastWri
  * @alpha
  */
 export declare const SyncComponents: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<ISyncComponentsType>;
+/**
+ * @alpha
+ */
+export declare const NetworkEntity: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkEntityType>;
+/**
+ * @alpha
+ */
+export declare const NetworkParent: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkParentType>;

package/dist-cjs/components/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncComponents = exports.Name = exports.Tween = exports.MeshCollider = exports.MeshRenderer = exports.Animator = exports.Material = exports.Transform = void 0;
+exports.NetworkParent = exports.NetworkEntity = exports.SyncComponents = exports.Name = exports.Tween = exports.MeshCollider = exports.MeshRenderer = exports.Animator = exports.Material = exports.Transform = void 0;
 const Animator_1 = require("./extended/Animator");
 const Material_1 = require("./extended/Material");
 const MeshCollider_1 = require("./extended/MeshCollider");
@@ -25,6 +25,8 @@ const MeshRenderer_1 = require("./extended/MeshRenderer");
 const Tween_1 = require("./extended/Tween");
 const Name_1 = __importDefault(require("./manual/Name"));
 const SyncComponents_1 = __importDefault(require("./manual/SyncComponents"));
+const NetworkEntity_1 = __importDefault(require("./manual/NetworkEntity"));
+const NetworkParent_1 = __importDefault(require("./manual/NetworkParent"));
 const Transform_1 = require("./manual/Transform");
 __exportStar(require("./generated/index.gen"), exports);
 /* @__PURE__ */
@@ -57,3 +59,15 @@ exports.Name = Name;
 /* @__PURE__ */
 const SyncComponents = (engine) => (0, SyncComponents_1.default)(engine);
 exports.SyncComponents = SyncComponents;
+/**
+ * @alpha
+ */
+/* @__PURE__ */
+const NetworkEntity = (engine) => (0, NetworkEntity_1.default)(engine);
+exports.NetworkEntity = NetworkEntity;
+/**
+ * @alpha
+ */
+/* @__PURE__ */
+const NetworkParent = (engine) => (0, NetworkParent_1.default)(engine);
+exports.NetworkParent = NetworkParent;

package/dist-cjs/components/manual/NetworkEntity.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from '../../engine';
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
+export interface INetowrkEntityType {
+    networkId: number;
+    entityId: Entity;
+}
+export type INetowrkEntity = LastWriteWinElementSetComponentDefinition<INetowrkEntityType>;
+declare function defineNetworkEntityComponent(engine: Pick<IEngine, 'defineComponent'>): import("../../engine").MapComponentDefinition<import("../..").MapResult<{
+    networkId: import("../../schemas").ISchema<number>;
+    entityId: import("../../schemas").ISchema<Entity>;
+}>>;
+export default defineNetworkEntityComponent;

package/dist-cjs/components/manual/NetworkEntity.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schemas_1 = require("../../schemas");
+function defineNetworkEntityComponent(engine) {
+    const EntityNetwork = engine.defineComponent('core-schema::Network-Entity', {
+        networkId: schemas_1.Schemas.Int64,
+        entityId: schemas_1.Schemas.Entity
+    });
+    return EntityNetwork;
+}
+exports.default = defineNetworkEntityComponent;

package/dist-cjs/components/manual/NetworkParent.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from '../../engine';
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
+export interface INetowrkParentType {
+    networkId: number;
+    entityId: Entity;
+}
+export type INetowrkParent = LastWriteWinElementSetComponentDefinition<INetowrkParentType>;
+declare function defineNetworkParentComponent(engine: Pick<IEngine, 'defineComponent'>): import("../../engine").MapComponentDefinition<import("../..").MapResult<{
+    networkId: import("../../schemas").ISchema<number>;
+    entityId: import("../../schemas").ISchema<Entity>;
+}>>;
+export default defineNetworkParentComponent;

package/dist-cjs/components/manual/NetworkParent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schemas_1 = require("../../schemas");
+function defineNetworkParentComponent(engine) {
+    const EntityNetwork = engine.defineComponent('core-schema::Network-Parent', {
+        networkId: schemas_1.Schemas.Int64,
+        entityId: schemas_1.Schemas.Entity
+    });
+    return EntityNetwork;
+}
+exports.default = defineNetworkParentComponent;

package/dist-cjs/components/types.d.ts

@@ -6,3 +6,5 @@ export type { TweenHelper, TweenComponentDefinitionExtended } from './extended/T
 export type { TransformComponentExtended, TransformTypeWithOptionals } from './manual/Transform';
 export type { NameComponent, NameType } from './manual/Name';
 export type { ISyncComponents, ISyncComponentsType } from './manual/SyncComponents';
+export type { INetowrkEntity, INetowrkEntityType } from './manual/NetworkEntity';
+export type { INetowrkParent, INetowrkParentType } from './manual/NetworkParent';

package/dist-cjs/engine/index.js

@@ -44,7 +44,6 @@ function preEngine() {
     const entityContainer = (0, entity_1.EntityContainer)();
     const componentsDefinition = new Map();
     const systems = (0, systems_1.SystemContainer)();
-    let networkManager;
     let sealed = false;
     function addSystem(fn, priority = systems_1.SYSTEMS_REGULAR_PRIORITY, name) {
         systems.add(fn, priority, name);
@@ -52,30 +51,22 @@ function preEngine() {
     function removeSystem(selector) {
         return systems.remove(selector);
     }
-    function getNetworkManager() {
-        if (!networkManager)
-            throw new Error('Network manager not initialized. Start CRDT Server');
-        return networkManager;
-    }
-    function addNetworkManager(reservedLocalEntities, range) {
-        entityContainer.setNetworkEntitiesRange(reservedLocalEntities, range);
-        networkManager = {
-            addEntity: () => entityContainer.generateEntity(true)
-        };
-        return networkManager;
-    }
     function addEntity() {
         const entity = entityContainer.generateEntity();
         return entity;
     }
     function removeEntity(entity) {
         for (const [, component] of componentsDefinition) {
+            // TODO: hack for the moment. It should be enough to delete the entity, but the renderer is not cleaning the components.
+            // So we still need the NetworkEntity to forward this message to the SyncTransport.
+            if (component.componentName === 'core-schema::Network-Entity')
+                continue;
             component.entityDeleted(entity, true);
         }
         return entityContainer.removeEntity(entity);
     }
     function removeEntityWithChildren(entity) {
-        return (0, tree_1.removeEntityWithChildren)({ removeEntity, defineComponentFromSchema, getEntitiesWith }, entity);
+        return (0, tree_1.removeEntityWithChildren)({ removeEntity, defineComponentFromSchema, getEntitiesWith, defineComponent }, entity);
     }
     function registerComponentDefinition(componentName, component) {
         /* istanbul ignore next */
@@ -152,7 +143,7 @@ function preEngine() {
         const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : (0, component_number_1.componentNumberFromName)(componentIdOrName);
         const component = componentsDefinition.get(componentId);
         if (!component) {
-            throw new Error(`Component ${componentId} not found. You need to declare the components at the beginnig of the engine declaration`);
+            throw new Error(`Component ${componentIdOrName} not found. You need to declare the components at the beginnig of the engine declaration`);
         }
         return component;
     }
@@ -226,9 +217,7 @@ function preEngine() {
         registerComponentDefinition,
         entityContainer,
         componentsIter,
-        seal,
-        addNetworkManager,
-        getNetworkManager
+        seal
     };
 }
 /**
@@ -272,9 +261,7 @@ function Engine(options) {
         CameraEntity: 2,
         getEntityState: partialEngine.entityContainer.getEntityState,
         addTransport: crdtSystem.addTransport,
-        entityContainer: partialEngine.entityContainer,
-        addNetworkManager: partialEngine.addNetworkManager,
-        getNetworkManager: partialEngine.getNetworkManager
+        entityContainer: partialEngine.entityContainer
     };
 }
 exports.Engine = Engine;

package/dist-cjs/engine/lww-element-set-component-definition.js

@@ -86,7 +86,10 @@ function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
     }
     return (msg) => {
         /* istanbul ignore next */
-        if (msg.type !== crdt_1.CrdtMessageType.PUT_COMPONENT && msg.type !== crdt_1.CrdtMessageType.DELETE_COMPONENT)
+        if (msg.type !== crdt_1.CrdtMessageType.PUT_COMPONENT &&
+            msg.type !== crdt_1.CrdtMessageType.PUT_COMPONENT_NETWORK &&
+            msg.type !== crdt_1.CrdtMessageType.DELETE_COMPONENT &&
+            msg.type !== crdt_1.CrdtMessageType.DELETE_COMPONENT_NETWORK)
             /* istanbul ignore next */
             return [null, data.get(msg.entityId)];
         const action = crdtRuleForCurrentState(msg);
@@ -95,7 +98,7 @@ function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
             case crdt_1.ProcessMessageResultType.StateUpdatedData:
             case crdt_1.ProcessMessageResultType.StateUpdatedTimestamp: {
                 timestamps.set(entity, msg.timestamp);
-                if (msg.type === crdt_1.CrdtMessageType.PUT_COMPONENT) {
+                if (msg.type === crdt_1.CrdtMessageType.PUT_COMPONENT || msg.type === crdt_1.CrdtMessageType.PUT_COMPONENT_NETWORK) {
                     const buf = new ByteBuffer_1.ReadWriteByteBuffer(msg.data);
                     data.set(entity, schema.deserialize(buf));
                 }

package/dist-cjs/engine/types.d.ts

@@ -227,16 +227,4 @@ export interface IEngine {
      * components that will be available to this engine and to run optimizations.
      */
     seal(): void;
-    /**
-     * @alpha
-     * Initialize network manager
-     */
-    addNetworkManager(reservedLocalEntities: number, range: [number, number]): {
-        addEntity: IEngine['addEntity'];
-    };
-    /**
-     * @alpha
-     * Get netowrk manager to create entities.
-     */
-    getNetworkManager(): ReturnType<IEngine['addNetworkManager']>;
 }