@dcl/ecs 7.1.12-4982829389.commit-f2f84bd → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/engine/entity.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityContainer = exports.EntityState = exports.EntityUtils = exports.MAX_ENTITY_NUMBER = exports.RESERVED_STATIC_ENTITIES = exports.AMOUNT_VERSION_AVAILABLE = exports.MAX_U16 = void 0;
+const gset_1 = require("../systems/crdt/gset");
+/**
+ * @internal
+ */
+exports.MAX_U16 = 0xffff;
+const MASK_UPPER_16_ON_32 = 0xffff0000;
+/**
+ * @internal
+ */
+exports.AMOUNT_VERSION_AVAILABLE = exports.MAX_U16 + 1;
+// This type matches with @dcl/crdt entity type.
+/**
+ * @internal
+ * This first 512 entities are reserved by the renderer
+ */
+exports.RESERVED_STATIC_ENTITIES = 512;
+/**
+ * @internal
+ */
+exports.MAX_ENTITY_NUMBER = exports.MAX_U16;
+/**
+ * @internal
+ */
+var EntityUtils;
+(function (EntityUtils) {
+    /**
+     * @returns [entityNumber, entityVersion]
+     */
+    function fromEntityId(entityId) {
+        return [(entityId & exports.MAX_U16) >>> 0, (((entityId & MASK_UPPER_16_ON_32) >> 16) & exports.MAX_U16) >>> 0];
+    }
+    EntityUtils.fromEntityId = fromEntityId;
+    /**
+     * @returns compound number from entityNumber and entityVerison
+     */
+    function toEntityId(entityNumber, entityVersion) {
+        return (((entityNumber & exports.MAX_U16) | ((entityVersion & exports.MAX_U16) << 16)) >>> 0);
+    }
+    EntityUtils.toEntityId = toEntityId;
+})(EntityUtils = exports.EntityUtils || (exports.EntityUtils = {}));
+/**
+ * @public
+ */
+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 = exports.EntityState || (exports.EntityState = {}));
+/**
+ * @internal
+ */
+function EntityContainer() {
+    let entityCounter = exports.RESERVED_STATIC_ENTITIES;
+    const usedEntities = new Set();
+    let toRemoveEntities = [];
+    const removedEntities = (0, gset_1.createVersionGSet)();
+    function generateNewEntity() {
+        if (entityCounter > exports.MAX_ENTITY_NUMBER - 1) {
+            throw new Error(`It fails trying to generate an entity out of range ${exports.MAX_ENTITY_NUMBER}.`);
+        }
+        const entityNumber = entityCounter++;
+        const entityVersion = removedEntities.getMap().has(entityNumber)
+            ? removedEntities.getMap().get(entityNumber) + 1
+            : 0;
+        const entity = EntityUtils.toEntityId(entityNumber, entityVersion);
+        if (usedEntities.has(entity)) {
+            return generateNewEntity();
+        }
+        usedEntities.add(entity);
+        return entity;
+    }
+    function generateEntity() {
+        // If all entities until `entityCounter` are being used, we need to generate another one
+        if (usedEntities.size + exports.RESERVED_STATIC_ENTITIES >= entityCounter) {
+            return generateNewEntity();
+        }
+        for (const [number, version] of removedEntities.getMap()) {
+            if (version < exports.MAX_U16) {
+                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) {
+        if (entity < exports.RESERVED_STATIC_ENTITIES)
+            return false;
+        if (usedEntities.has(entity)) {
+            usedEntities.delete(entity);
+            toRemoveEntities.push(entity);
+        }
+        else {
+            updateRemovedEntity(entity);
+        }
+        return true;
+    }
+    function releaseRemovedEntities() {
+        const arr = toRemoveEntities;
+        if (arr.length) {
+            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);
+        // if the entity was removed then abort fast
+        if (removedEntities.has(n, 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 < exports.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,
+        removeEntity,
+        getExistingEntities() {
+            return new Set(usedEntities);
+        },
+        getEntityState,
+        releaseRemovedEntities,
+        updateRemovedEntity,
+        updateUsedEntity
+    };
+}
+exports.EntityContainer = EntityContainer;

package/dist-cjs/engine/grow-only-value-set-component-definition.d.ts

@@ -0,0 +1,8 @@
+import { DeepReadonly } from './readonly';
+/**
+ * @public
+ */
+export type ValueSetOptions<T> = {
+    timestampFunction: (value: DeepReadonly<T>) => number;
+    maxElements: number;
+};

package/dist-cjs/engine/grow-only-value-set-component-definition.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValueSetComponentDefinitionFromSchema = void 0;
+const ByteBuffer_1 = require("../serialization/ByteBuffer");
+const crdt_1 = require("../serialization/crdt");
+const invariant_1 = require("../runtime/invariant");
+const emptyReadonlySet = freezeSet(new Set());
+function frozenError() {
+    throw new Error('The set is frozen');
+}
+function freezeSet(set) {
+    ;
+    set.add = frozenError;
+    set.clear = frozenError;
+    return set;
+}
+function sortByTimestamp(a, b) {
+    return a.timestamp > b.timestamp ? 1 : -1;
+}
+/**
+ * @internal
+ */
+function createValueSetComponentDefinitionFromSchema(componentName, componentId, schema, options) {
+    const data = new Map();
+    const dirtyIterator = new Set();
+    const queuedCommands = [];
+    // only sort the array if the latest (N) element has a timestamp <= N-1
+    function shouldSort(row) {
+        const len = row.raw.length;
+        if (len > 1 && row.raw[len - 1].timestamp <= row.raw[len - 2].timestamp) {
+            return true;
+        }
+        return false;
+    }
+    function gotUpdated(entity) {
+        const row = data.get(entity);
+        /* istanbul ignore else */
+        if (row) {
+            if (shouldSort(row)) {
+                row.raw.sort(sortByTimestamp);
+            }
+            while (row.raw.length > options.maxElements) {
+                row.raw.shift();
+            }
+            const frozenSet = freezeSet(new Set(row?.raw.map(($) => $.value)));
+            row.frozenSet = frozenSet;
+            return frozenSet;
+        }
+        else {
+            /* istanbul ignore next */
+            return emptyReadonlySet;
+        }
+    }
+    function append(entity, value) {
+        let row = data.get(entity);
+        if (!row) {
+            row = { raw: [], frozenSet: emptyReadonlySet };
+            data.set(entity, row);
+        }
+        const usedValue = schema.extend ? schema.extend(value) : value;
+        const timestamp = options.timestampFunction(usedValue);
+        if (invariant_1.__DEV__) {
+            // only freeze the objects in dev mode to warn the developers because
+            // it is an expensive operation
+            Object.freeze(usedValue);
+        }
+        row.raw.push({ value: usedValue, timestamp });
+        return { set: gotUpdated(entity), value: usedValue };
+    }
+    const ret = {
+        get componentId() {
+            return componentId;
+        },
+        get componentName() {
+            return componentName;
+        },
+        get componentType() {
+            // a getter is used here to prevent accidental changes
+            return 1 /* ComponentType.GrowOnlyValueSet */;
+        },
+        schema,
+        has(entity) {
+            return data.has(entity);
+        },
+        entityDeleted(entity) {
+            data.delete(entity);
+        },
+        get(entity) {
+            const values = data.get(entity);
+            if (values) {
+                return values.frozenSet;
+            }
+            else {
+                return emptyReadonlySet;
+            }
+        },
+        addValue(entity, rawValue) {
+            const { set, value } = append(entity, rawValue);
+            dirtyIterator.add(entity);
+            const buf = new ByteBuffer_1.ReadWriteByteBuffer();
+            schema.serialize(value, buf);
+            queuedCommands.push({
+                componentId,
+                data: buf.toBinary(),
+                entityId: entity,
+                timestamp: 0,
+                type: crdt_1.CrdtMessageType.APPEND_VALUE
+            });
+            return set;
+        },
+        *iterator() {
+            for (const [entity, component] of data) {
+                yield [entity, component.frozenSet];
+            }
+        },
+        *dirtyIterator() {
+            for (const entity of dirtyIterator) {
+                yield entity;
+            }
+        },
+        getCrdtUpdates() {
+            // return a copy of the commands, and then clear the local copy
+            dirtyIterator.clear();
+            return queuedCommands.splice(0, queuedCommands.length);
+        },
+        updateFromCrdt(_body) {
+            if (_body.type === crdt_1.CrdtMessageType.APPEND_VALUE) {
+                const buf = new ByteBuffer_1.ReadWriteByteBuffer(_body.data);
+                append(_body.entityId, schema.deserialize(buf));
+            }
+            return [null, undefined];
+        },
+        dumpCrdtStateToBuffer: function (buffer) {
+            for (const [entity, { raw }] of data) {
+                for (const it of raw) {
+                    const buf = new ByteBuffer_1.ReadWriteByteBuffer();
+                    schema.serialize(it.value, buf);
+                    crdt_1.AppendValueOperation.write(entity, 0, componentId, buf.toBinary(), buffer);
+                }
+            }
+        }
+    };
+    return ret;
+}
+exports.createValueSetComponentDefinitionFromSchema = createValueSetComponentDefinitionFromSchema;

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

@@ -0,0 +1,15 @@
+import { ByteBuffer } from '../serialization/ByteBuffer';
+import { OnChangeFunction } from '../systems/crdt';
+import { Entity } from './entity';
+import { SystemItem } from './systems';
+import type { IEngine, IEngineOptions } from './types';
+export * from './input';
+export * from './readonly';
+export * from './types';
+export { Entity, ByteBuffer, SystemItem, OnChangeFunction };
+/**
+ * Internal constructor of new engines, this is an internal API
+ * @public
+ * @deprecated Prevent manual usage prefer "engine" for scene development
+ */
+export declare function Engine(options?: IEngineOptions): IEngine;

package/dist-cjs/engine/index.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Engine = void 0;
+const components = __importStar(require("../components"));
+const component_number_1 = require("../components/component-number");
+const invariant_1 = require("../runtime/invariant");
+const schemas_1 = require("../schemas");
+const crdt_1 = require("../systems/crdt");
+const lww_element_set_component_definition_1 = require("./lww-element-set-component-definition");
+const entity_1 = require("./entity");
+const systems_1 = require("./systems");
+const grow_only_value_set_component_definition_1 = require("./grow-only-value-set-component-definition");
+__exportStar(require("./input"), exports);
+__exportStar(require("./readonly"), exports);
+__exportStar(require("./types"), exports);
+function preEngine() {
+    const entityContainer = (0, entity_1.EntityContainer)();
+    const componentsDefinition = new Map();
+    const systems = (0, systems_1.SystemContainer)();
+    let sealed = false;
+    function addSystem(fn, priority = systems_1.SYSTEMS_REGULAR_PRIORITY, name) {
+        systems.add(fn, priority, name);
+    }
+    function removeSystem(selector) {
+        return systems.remove(selector);
+    }
+    function addEntity() {
+        const entity = entityContainer.generateEntity();
+        return entity;
+    }
+    function removeEntity(entity) {
+        for (const [, component] of componentsDefinition) {
+            component.entityDeleted(entity, true);
+        }
+        return entityContainer.removeEntity(entity);
+    }
+    function registerComponentDefinition(componentName, component) {
+        /* istanbul ignore next */
+        if (sealed)
+            throw new Error('Engine is already sealed. No components can be added at this stage');
+        const componentId = (0, component_number_1.componentNumberFromName)(componentName);
+        const prev = componentsDefinition.get(componentId);
+        if (prev) {
+            throw new Error(`Component number ${componentId} was already registered.`);
+        }
+        /* istanbul ignore next */
+        if (component.componentName !== componentName) {
+            throw new Error(`Component name doesn't match componentDefinition.componentName ${componentName} != ${component.componentName}`);
+        }
+        /* istanbul ignore next */
+        if (component.componentId !== componentId) {
+            throw new Error(`Component number doesn't match componentDefinition.componentId ${componentId} != ${component.componentId}`);
+        }
+        componentsDefinition.set(componentId, component);
+        return component;
+    }
+    function defineComponentFromSchema(componentName, schema) {
+        /* istanbul ignore next */
+        if (sealed)
+            throw new Error('Engine is already sealed. No components can be added at this stage');
+        const componentId = (0, component_number_1.componentNumberFromName)(componentName);
+        const prev = componentsDefinition.get(componentId);
+        if (prev) {
+            // TODO: assert spec === prev.spec
+            return prev;
+        }
+        const newComponent = (0, lww_element_set_component_definition_1.createComponentDefinitionFromSchema)(componentName, componentId, schema);
+        componentsDefinition.set(componentId, newComponent);
+        return newComponent;
+    }
+    function defineValueSetComponentFromSchema(componentName, schema, options) {
+        /* istanbul ignore next */
+        if (sealed)
+            throw new Error('Engine is already sealed. No components can be added at this stage');
+        const componentId = (0, component_number_1.componentNumberFromName)(componentName);
+        const prev = componentsDefinition.get(componentId);
+        if (prev) {
+            // TODO: assert spec === prev.spec
+            return prev;
+        }
+        const newComponent = (0, grow_only_value_set_component_definition_1.createValueSetComponentDefinitionFromSchema)(componentName, componentId, schema, options);
+        componentsDefinition.set(componentId, newComponent);
+        return newComponent;
+    }
+    function defineComponent(componentName, mapSpec, constructorDefault) {
+        if (sealed)
+            throw new Error('Engine is already sealed. No components can be added at this stage');
+        const componentId = (0, component_number_1.componentNumberFromName)(componentName);
+        const prev = componentsDefinition.get(componentId);
+        if (prev) {
+            // TODO: assert spec === prev.spec
+            return prev;
+        }
+        const schemaSpec = schemas_1.Schemas.Map(mapSpec, constructorDefault);
+        const def = (0, lww_element_set_component_definition_1.createComponentDefinitionFromSchema)(componentName, componentId, schemaSpec);
+        const newComponent = {
+            ...def,
+            create(entity, val) {
+                return def.create(entity, val);
+            },
+            createOrReplace(entity, val) {
+                return def.createOrReplace(entity, val);
+            }
+        };
+        componentsDefinition.set(componentId, newComponent);
+        return newComponent;
+    }
+    function getComponent(componentIdOrName) {
+        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`);
+        }
+        return component;
+    }
+    function getComponentOrNull(componentIdOrName) {
+        const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : (0, component_number_1.componentNumberFromName)(componentIdOrName);
+        return (componentsDefinition.get(componentId) ??
+            /* istanbul ignore next */
+            null);
+    }
+    function* getEntitiesWith(...components) {
+        for (const [entity, ...groupComp] of getComponentDefGroup(...components)) {
+            yield [entity, ...groupComp.map((c) => c.get(entity))];
+        }
+    }
+    function* getComponentDefGroup(...args) {
+        const [firstComponentDef, ...componentDefinitions] = args;
+        for (const [entity] of firstComponentDef.iterator()) {
+            let matches = true;
+            for (const componentDef of componentDefinitions) {
+                if (!componentDef.has(entity)) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                yield [entity, ...args];
+            }
+        }
+    }
+    function getSystems() {
+        return systems.getSystems();
+    }
+    function componentsIter() {
+        return componentsDefinition.values();
+    }
+    function removeComponentDefinition(componentIdOrName) {
+        if (sealed)
+            throw new Error('Engine is already sealed. No components can be removed at this stage');
+        const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : (0, component_number_1.componentNumberFromName)(componentIdOrName);
+        componentsDefinition.delete(componentId);
+    }
+    components.Transform({ defineComponentFromSchema });
+    function seal() {
+        if (!sealed) {
+            sealed = true;
+        }
+    }
+    return {
+        addEntity,
+        removeEntity,
+        addSystem,
+        getSystems,
+        removeSystem,
+        defineComponent,
+        defineComponentFromSchema,
+        defineValueSetComponentFromSchema,
+        getEntitiesWith,
+        getComponent,
+        getComponentOrNull,
+        removeComponentDefinition,
+        registerComponentDefinition,
+        entityContainer,
+        componentsIter,
+        seal
+    };
+}
+/**
+ * Internal constructor of new engines, this is an internal API
+ * @public
+ * @deprecated Prevent manual usage prefer "engine" for scene development
+ */
+function Engine(options) {
+    const partialEngine = preEngine();
+    const crdtSystem = (0, crdt_1.crdtSceneSystem)(partialEngine, options?.onChangeFunction || null);
+    async function update(dt) {
+        await crdtSystem.receiveMessages();
+        for (const system of partialEngine.getSystems()) {
+            const ret = system.fn(dt);
+            (0, invariant_1.checkNotThenable)(ret, `A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
+        }
+        // get the deleted entities to send the DeleteEntity CRDT commands
+        const deletedEntites = partialEngine.entityContainer.releaseRemovedEntities();
+        await crdtSystem.sendMessages(deletedEntites);
+    }
+    return {
+        addEntity: partialEngine.addEntity,
+        removeEntity: partialEngine.removeEntity,
+        addSystem: partialEngine.addSystem,
+        removeSystem: partialEngine.removeSystem,
+        defineComponent: partialEngine.defineComponent,
+        defineComponentFromSchema: partialEngine.defineComponentFromSchema,
+        defineValueSetComponentFromSchema: partialEngine.defineValueSetComponentFromSchema,
+        registerComponentDefinition: partialEngine.registerComponentDefinition,
+        getEntitiesWith: partialEngine.getEntitiesWith,
+        getComponent: partialEngine.getComponent,
+        getComponentOrNull: partialEngine.getComponentOrNull,
+        removeComponentDefinition: partialEngine.removeComponentDefinition,
+        componentsIter: partialEngine.componentsIter,
+        seal: partialEngine.seal,
+        update,
+        RootEntity: 0,
+        PlayerEntity: 1,
+        CameraEntity: 2,
+        getEntityState: partialEngine.entityContainer.getEntityState,
+        addTransport: crdtSystem.addTransport,
+        entityContainer: partialEngine.entityContainer
+    };
+}
+exports.Engine = Engine;

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

@@ -0,0 +1,34 @@
+import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
+import { PointerEventType } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
+import { PBPointerEventsResult } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+import { Entity } from './entity';
+/**
+ * @public
+ */
+export type IInputSystem = {
+    /**
+     * @public
+     * Check if a pointer event has been emitted in the last tick-update.
+     * @param inputAction - the input action to query
+     * @param pointerEventType - the pointer event type to query
+     * @param entity - the entity to query, ignore for global
+     * @returns boolean
+     */
+    isTriggered: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => boolean;
+    /**
+     * @public
+     * Check if an input action is currently being pressed.
+     * @param inputAction - the input action to query
+     * @returns boolean
+     */
+    isPressed: (inputAction: InputAction) => boolean;
+    /**
+     * @public
+     * Get the input command info if a pointer event has been emitted in the last tick-update.
+     * @param inputAction - the input action to query
+     * @param pointerEventType - the pointer event type to query
+     * @param entity - the entity to query, ignore for global
+     * @returns the input command info or undefined if there is no command in the last tick-update
+     */
+    getInputCommand: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => PBPointerEventsResult | null;
+};