@dcl/ecs 7.0.6-3824930139.commit-9bd6c05 → 7.0.6-3832097301.commit-4e46b20

package/dist/engine/component.js

@@ -1,4 +1,4 @@
-import { createByteBuffer } from '../serialization/ByteBuffer';
+import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
 import { deepReadonly } from './readonly';
 export function defineComponent(componentId, spec
 // meta: { syncFlags }
@@ -92,7 +92,7 @@ export function defineComponent(componentId, spec
             if (!component) {
                 throw new Error(`[toBinary] Component ${componentId} for ${entity} not found`);
             }
-            const writeBuffer = createByteBuffer();
+            const writeBuffer = new ReadWriteByteBuffer();
             spec.serialize(component, writeBuffer);
             return writeBuffer;
         },
@@ -101,7 +101,7 @@ export function defineComponent(componentId, spec
             if (!component) {
                 return null;
             }
-            const writeBuffer = createByteBuffer();
+            const writeBuffer = new ReadWriteByteBuffer();
             spec.serialize(component, writeBuffer);
             return writeBuffer;
         },

package/dist/engine/entity.d.ts

@@ -17,7 +17,7 @@ export declare const AMOUNT_VERSION_AVAILABLE: number;
  * Convertion from its compound numbers to entity:
  * entity = (entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)
  */
-export declare type Entity = uint32 & {
+export declare type Entity = number & {
     __entity_type: '';
 };
 /**
@@ -28,12 +28,41 @@ export declare const RESERVED_STATIC_ENTITIES = 512;
  * @public
  */
 export declare const MAX_ENTITY_NUMBER = 65535;
-export declare function EntityContainer(): {
+export declare namespace EntityUtils {
+    /**
+     * @returns [entityNumber, entityVersion]
+     */
+    function fromEntityId(entityId: Entity): [number, number];
+    /**
+     * @returns compound number from entityNumber and entityVerison
+     */
+    function toEntityId(entityNumber: number, entityVersion: number): Entity;
+}
+/**
+ * @public
+ */
+export declare enum EntityState {
+    Unknown = 0,
+    /**
+     * The entity was generated and added to the usedEntities set
+     */
+    UsedEntity = 1,
+    /**
+     * The entity was removed from current engine or remotely
+     */
+    Removed = 2,
+    /**
+     * The entity is reserved number.
+     */
+    Reserved = 3
+}
+export declare type EntityContainer = {
     generateEntity(): Entity;
     removeEntity(entity: Entity): boolean;
-    entityExists(entity: Entity): boolean;
+    getEntityState(entity: Entity): EntityState;
     getExistingEntities(): Set<Entity>;
-    entityVersion: (entity: Entity) => number;
-    entityNumber: (entity: Entity) => number;
-    entityId: (entityNumber: number, entityVersion: number) => Entity;
+    releaseRemovedEntities(): Entity[];
+    updateRemovedEntity(entity: Entity): boolean;
+    updateUsedEntity(entity: Entity): boolean;
 };
+export declare function EntityContainer(): EntityContainer;

package/dist/engine/entity.js

@@ -1,6 +1,8 @@
+import { createGSet } from '@dcl/crdt/dist/gset';
 export const MAX_U16 = 0xffff;
 export const MASK_UPPER_16_ON_32 = 0xffff0000;
 export const AMOUNT_VERSION_AVAILABLE = MAX_U16 + 1;
+// This type matches with @dcl/crdt entity type.
 /**
  * @public This first 512 entities are reserved by the renderer
  */
@@ -9,64 +11,151 @@ export const RESERVED_STATIC_ENTITIES = 512;
  * @public
  */
 export const MAX_ENTITY_NUMBER = MAX_U16;
-export function EntityContainer() {
-    let entityCounter = RESERVED_STATIC_ENTITIES;
-    const usedEntities = new Set();
-    const removedEntities = new Map();
-    function entityVersion(entity) {
-        return (((entity & MASK_UPPER_16_ON_32) >> 16) & MAX_U16) >>> 0;
-    }
-    function entityNumber(entity) {
-        return (entity & MAX_U16) >>> 0;
+export var EntityUtils;
+(function (EntityUtils) {
+    /**
+     * @returns [entityNumber, entityVersion]
+     */
+    function fromEntityId(entityId) {
+        return [
+            (entityId & MAX_U16) >>> 0,
+            (((entityId & MASK_UPPER_16_ON_32) >> 16) & MAX_U16) >>> 0
+        ];
     }
-    function entityId(entityNumber, entityVersion) {
+    EntityUtils.fromEntityId = fromEntityId;
+    /**
+     * @returns compound number from entityNumber and entityVerison
+     */
+    function toEntityId(entityNumber, entityVersion) {
         return (((entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)) >>>
             0);
     }
+    EntityUtils.toEntityId = toEntityId;
+})(EntityUtils || (EntityUtils = {}));
+/**
+ * @public
+ */
+export var EntityState;
+(function (EntityState) {
+    EntityState[EntityState["Unknown"] = 0] = "Unknown";
+    /**
+     * The entity was generated and added to the usedEntities set
+     */
+    EntityState[EntityState["UsedEntity"] = 1] = "UsedEntity";
+    /**
+     * The entity was removed from current engine or remotely
+     */
+    EntityState[EntityState["Removed"] = 2] = "Removed";
+    /**
+     * The entity is reserved number.
+     */
+    EntityState[EntityState["Reserved"] = 3] = "Reserved";
+})(EntityState || (EntityState = {}));
+export function EntityContainer() {
+    let entityCounter = RESERVED_STATIC_ENTITIES;
+    const usedEntities = new Set();
+    let toRemoveEntities = [];
+    const removedEntities = createGSet();
     function generateNewEntity() {
         if (entityCounter > MAX_ENTITY_NUMBER - 1) {
             throw new Error(`It fails trying to generate an entity out of range ${MAX_ENTITY_NUMBER}.`);
         }
-        const entity = entityCounter++;
+        const entityNumber = entityCounter++;
+        const entityVersion = removedEntities.getMap().has(entityNumber)
+            ? removedEntities.getMap().get(entityNumber) + 1
+            : 0;
+        const entity = EntityUtils.toEntityId(entityNumber, entityVersion);
         usedEntities.add(entity);
         return entity;
     }
     function generateEntity() {
+        // If all entities until `entityCounter` are being used, we need to generate another one
         if (usedEntities.size + RESERVED_STATIC_ENTITIES >= entityCounter) {
             return generateNewEntity();
         }
-        for (const [number, version] of removedEntities) {
+        for (const [number, version] of removedEntities.getMap()) {
             if (version < MAX_U16) {
-                const entity = entityId(number, version + 1);
-                usedEntities.add(entity);
-                removedEntities.delete(number);
-                return entity;
+                const entity = EntityUtils.toEntityId(number, version + 1);
+                // If the entity is not being used, we can re-use it
+                // If the entity was removed in this tick, we're not counting for the usedEntities, but we have it in the toRemoveEntityArray
+                if (!usedEntities.has(entity) && !toRemoveEntities.includes(entity)) {
+                    usedEntities.add(entity);
+                    return entity;
+                }
             }
         }
         return generateNewEntity();
     }
     function removeEntity(entity) {
-        const deleted = usedEntities.delete(entity);
-        if (deleted) {
-            removedEntities.set(entityNumber(entity), entityVersion(entity));
+        if (entity < RESERVED_STATIC_ENTITIES)
+            return false;
+        if (usedEntities.has(entity)) {
+            usedEntities.delete(entity);
+            toRemoveEntities.push(entity);
+        }
+        else {
+            updateRemovedEntity(entity);
         }
-        return deleted;
+        return true;
+    }
+    function releaseRemovedEntities() {
+        const arr = toRemoveEntities;
+        toRemoveEntities = [];
+        for (const entity of arr) {
+            const [n, v] = EntityUtils.fromEntityId(entity);
+            removedEntities.addTo(n, v);
+        }
+        return arr;
+    }
+    function updateRemovedEntity(entity) {
+        const [n, v] = EntityUtils.fromEntityId(entity);
+        // Update the removed entities map
+        removedEntities.addTo(n, v);
+        // Remove the usedEntities if exist
+        for (let i = 0; i <= v; i++) {
+            usedEntities.delete(EntityUtils.toEntityId(n, i));
+        }
+        return true;
+    }
+    function updateUsedEntity(entity) {
+        const [n, v] = EntityUtils.fromEntityId(entity);
+        const removedVersion = removedEntities.getMap().get(n);
+        if (removedVersion !== undefined && removedVersion >= v) {
+            return false;
+        }
+        // Update
+        if (v > 0) {
+            for (let i = 0; i <= v - 1; i++) {
+                usedEntities.delete(EntityUtils.toEntityId(n, i));
+            }
+            removedEntities.addTo(n, v - 1);
+        }
+        usedEntities.add(entity);
+        return true;
+    }
+    function getEntityState(entity) {
+        const [n, v] = EntityUtils.fromEntityId(entity);
+        if (n < RESERVED_STATIC_ENTITIES) {
+            return EntityState.Reserved;
+        }
+        if (usedEntities.has(entity)) {
+            return EntityState.UsedEntity;
+        }
+        const removedVersion = removedEntities.getMap().get(n);
+        if (removedVersion !== undefined && removedVersion >= v) {
+            return EntityState.Removed;
+        }
+        return EntityState.Unknown;
     }
     return {
-        generateEntity() {
-            return generateEntity();
-        },
-        removeEntity(entity) {
-            return removeEntity(entity);
-        },
-        entityExists(entity) {
-            return entity < RESERVED_STATIC_ENTITIES || usedEntities.has(entity);
-        },
+        generateEntity,
+        removeEntity,
         getExistingEntities() {
             return new Set(usedEntities);
         },
-        entityVersion,
-        entityNumber,
-        entityId
+        getEntityState,
+        releaseRemovedEntities,
+        updateRemovedEntity,
+        updateUsedEntity
     };
 }

package/dist/engine/index.js

@@ -22,9 +22,6 @@ function preEngine() {
         const entity = entityContainer.generateEntity();
         return entity;
     }
-    function entityExists(entity) {
-        return entityContainer.entityExists(entity);
-    }
     function removeEntity(entity) {
         for (const [, component] of componentsDefinition) {
             if (component.has(entity)) {
@@ -131,8 +128,6 @@ function preEngine() {
         }
     }
     return {
-        entityExists,
-        componentsDefinition,
         addEntity,
         removeEntity,
         addSystem,
@@ -146,6 +141,7 @@ function preEngine() {
         removeComponentDefinition,
         removeEntityWithChildren,
         registerCustomComponent,
+        entityContainer,
         componentsIter
     };
 }
@@ -162,8 +158,9 @@ export function Engine(options) {
             checkNotThenable(ret, `A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
         }
         const dirtyEntities = crdtSystem.updateState();
-        await crdtSystem.sendMessages(dirtyEntities);
-        for (const [_componentId, definition] of engine.componentsDefinition) {
+        const deletedEntites = engine.entityContainer.releaseRemovedEntities();
+        await crdtSystem.sendMessages(dirtyEntities, deletedEntites);
+        for (const definition of engine.componentsIter()) {
             definition.clearDirty();
         }
     }
@@ -185,9 +182,9 @@ export function Engine(options) {
         RootEntity: 0,
         PlayerEntity: 1,
         CameraEntity: 2,
-        entityExists: engine.entityExists,
+        getEntityState: engine.entityContainer.getEntityState,
         addTransport: crdtSystem.addTransport,
         getCrdtState: crdtSystem.getCrdt,
-        componentsDefinition: engine.componentsDefinition
+        entityContainer: engine.entityContainer
     };
 }

package/dist/engine/types.d.ts

@@ -2,7 +2,7 @@ import type { ISchema } from '../schemas/ISchema';
 import { MapResult, Spec } from '../schemas/Map';
 import { Transport } from '../systems/crdt/types';
 import { ComponentDefinition } from './component';
-import { Entity } from './entity';
+import { Entity, EntityContainer, EntityState } from './entity';
 import { ReadonlyComponentSchema } from './readonly';
 import { SystemFn } from './systems';
 export { ISchema } from '../schemas/ISchema';
@@ -53,11 +53,11 @@ export declare type IEngine = {
      */
     removeEntityWithChildren(firstEntity: Entity): void;
     /**
-     * Check if an entity exists in the engine
+     * Check the state of an entityin  the engine
      * @param entity - the entity to validate
-     * @returns true if the entity exists in the engine
+     * @returns known enum value
      */
-    entityExists(entity: Entity): boolean;
+    getEntityState(entity: Entity): EntityState;
     /**
      * Add the system to the engine. It will be called every tick updated.
      * @param system - function that receives the delta time between last tick and current one.
@@ -173,6 +173,10 @@ export declare type IEngine = {
      * @param transport - transport which changes its onmessage to process CRDT messages
      */
     addTransport(transport: Transport): void;
+    /**
+     * Entity continaer
+     */
+    entityContainer: EntityContainer;
     /**
      * Iterator of registered components
      */

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export declare const MeshRenderer: import("./components/types").MeshRendererComp
 export declare const MeshCollider: import("./components/types").MeshColliderComponentDefinitionExtended;
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';
+export * from './serialization/crdt';

package/dist/index.js

@@ -22,3 +22,4 @@ import { engine } from './runtime/initialization';
 // export components for global engine
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';
+export * from './serialization/crdt';

package/dist/runtime/types.d.ts

@@ -1,6 +1,5 @@
 export type { SystemFn } from '../engine/systems';
 export type { TransportMessage, ReceiveMessage, Transport } from '../systems/crdt/types';
-export type { WireMessage } from '../serialization/wireMessage';
 export { TransformType, TransformComponent } from '../components/legacy/Transform';
 export * from '../engine/component';
 export * from '../schemas/typing';

package/dist/serialization/ByteBuffer/index.d.ts

@@ -1,29 +1,3 @@
-/**
- * @param writing - writing option, see object specs.
- * @param reading - reading option, see object specs.
- * @param initialCapacity - Initial capacity of buffer to allocate, ignored if you use writing or reading options
- */
-export interface CreateByteBufferOptions {
-    /**
-     * @param buffer - a buffer already allocated to read from there.
-     * @param currentOffset - set the cursor where begins to read. Default 0
-     * @param length - delimite where the valid data ends. Default: buffer.length
-     */
-    reading?: {
-        buffer: Uint8Array;
-        length?: number;
-        currentOffset: number;
-    };
-    /**
-     * @param buffer - a buffer already allocated to write there.
-     * @param currentOffset - set the cursor to not start writing from the begin of it. Default 0
-     */
-    writing?: {
-        buffer: Uint8Array;
-        currentOffset?: number;
-    };
-    initialCapacity?: number;
-}
 /**
  * ByteBuffer is a wrapper of DataView which also adds a read and write offset.
  *  Also in a write operation it resizes the buffer is being used if it needs.
@@ -31,7 +5,73 @@ export interface CreateByteBufferOptions {
  * - Use read and write function to generate or consume data.
  * - Use set and get only if you are sure that you're doing.
  */
-export declare function createByteBuffer(options?: CreateByteBufferOptions): ByteBuffer;
+export declare class ReadWriteByteBuffer implements ByteBuffer {
+    #private;
+    _buffer: Uint8Array;
+    view: DataView;
+    woffset: number;
+    roffset: number;
+    /**
+     * @param buffer - The initial buffer, provide a buffer if you need to set "initial capacity"
+     * @param readingOffset - Set the cursor where begins to read. Default 0
+     * @param writingOffset - Set the cursor to not start writing from the begin of it. Defaults to the buffer size
+     */
+    constructor(buffer?: Uint8Array | undefined, readingOffset?: number | undefined, writingOffset?: number | undefined);
+    buffer(): Uint8Array;
+    bufferLength(): number;
+    resetBuffer(): void;
+    currentReadOffset(): number;
+    currentWriteOffset(): number;
+    incrementReadOffset(amount: number): number;
+    remainingBytes(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): bigint;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): bigint;
+    readBuffer(): Uint8Array;
+    readUtf8String(): string;
+    incrementWriteOffset(amount: number): number;
+    toBinary(): Uint8Array;
+    toCopiedBinary(): Uint8Array;
+    writeBuffer(value: Uint8Array, writeLength?: boolean): void;
+    writeUtf8String(value: string, writeLength?: boolean): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt64(value: bigint): void;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: bigint): void;
+    getFloat32(offset: number): number;
+    getFloat64(offset: number): number;
+    getInt8(offset: number): number;
+    getInt16(offset: number): number;
+    getInt32(offset: number): number;
+    getInt64(offset: number): bigint;
+    getUint8(offset: number): number;
+    getUint16(offset: number): number;
+    getUint32(offset: number): number;
+    getUint64(offset: number): bigint;
+    setFloat32(offset: number, value: number): void;
+    setFloat64(offset: number, value: number): void;
+    setInt8(offset: number, value: number): void;
+    setInt16(offset: number, value: number): void;
+    setInt32(offset: number, value: number): void;
+    setInt64(offset: number, value: bigint): void;
+    setUint8(offset: number, value: number): void;
+    setUint16(offset: number, value: number): void;
+    setUint32(offset: number, value: number): void;
+    setUint64(offset: number, value: bigint): void;
+}
 /**
  * @public
  */
@@ -89,10 +129,6 @@ export declare type ByteBuffer = {
      * @returns The offset when this reserving starts.
      */
     incrementWriteOffset(amount: number): number;
-    /**
-     * @returns The total number of bytes writen in the buffer.
-     */
-    size(): number;
     /**
      * Take care using this function, if you modify the data after, the
      * returned subarray will change too. If you'll modify the content of the