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

package/dist-cjs/engine/input.js

@@ -0,0 +1,219 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInputSystem = void 0;
+const components = __importStar(require("../components"));
+const InputCommands = [
+    0 /* InputAction.IA_POINTER */,
+    1 /* InputAction.IA_PRIMARY */,
+    2 /* InputAction.IA_SECONDARY */,
+    4 /* InputAction.IA_FORWARD */,
+    5 /* InputAction.IA_BACKWARD */,
+    6 /* InputAction.IA_RIGHT */,
+    7 /* InputAction.IA_LEFT */,
+    8 /* InputAction.IA_JUMP */,
+    9 /* InputAction.IA_WALK */,
+    10 /* InputAction.IA_ACTION_3 */,
+    11 /* InputAction.IA_ACTION_4 */,
+    12 /* InputAction.IA_ACTION_5 */,
+    13 /* InputAction.IA_ACTION_6 */
+];
+const InputStateUpdateSystemPriority = 1 << 20;
+/**
+ * @internal
+ */
+function createInputSystem(engine) {
+    const PointerEventsResult = components.PointerEventsResult(engine);
+    const globalState = {
+        previousFrameMaxTimestamp: 0,
+        currentFrameMaxTimestamp: 0,
+        buttonState: new Map(),
+        thisFrameCommands: []
+    };
+    function findLastAction(pointerEventType, inputAction, entity) {
+        const ascendingTimestampIterator = PointerEventsResult.get(entity);
+        for (const command of Array.from(ascendingTimestampIterator).reverse()) {
+            if (command.button === inputAction && command.state === pointerEventType) {
+                return command;
+            }
+        }
+    }
+    function* findCommandsByActionDescending(inputAction, entity) {
+        const ascendingTimestampIterator = PointerEventsResult.get(entity);
+        for (const command of Array.from(ascendingTimestampIterator).reverse()) {
+            if (command.button === inputAction) {
+                yield command;
+            }
+        }
+    }
+    function buttonStateUpdateSystem() {
+        // first store the previous' frame timestamp
+        let maxTimestamp = globalState.currentFrameMaxTimestamp;
+        globalState.previousFrameMaxTimestamp = maxTimestamp;
+        if (globalState.thisFrameCommands.length) {
+            globalState.thisFrameCommands = [];
+        }
+        // then iterate over all new commands
+        for (const [, commands] of engine.getEntitiesWith(PointerEventsResult)) {
+            // TODO: adapt the gset component to have a cached "reversed" option by default
+            const arrayCommands = Array.from(commands);
+            for (let i = arrayCommands.length - 1; i >= 0; i--) {
+                const command = arrayCommands[i];
+                if (command.timestamp > maxTimestamp) {
+                    maxTimestamp = command.timestamp;
+                }
+                if (command.timestamp > globalState.previousFrameMaxTimestamp) {
+                    globalState.thisFrameCommands.push(command);
+                }
+                if (command.state === 0 /* PointerEventType.PET_UP */ || command.state === 1 /* PointerEventType.PET_DOWN */) {
+                    const prevCommand = globalState.buttonState.get(command.button);
+                    if (!prevCommand || command.timestamp > prevCommand.timestamp) {
+                        globalState.buttonState.set(command.button, command);
+                    }
+                    else {
+                        // since we are iterating a descending array, we can early finish the
+                        // loop
+                        break;
+                    }
+                }
+            }
+        }
+        // update current frame's max timestamp
+        globalState.currentFrameMaxTimestamp = maxTimestamp;
+    }
+    engine.addSystem(buttonStateUpdateSystem, InputStateUpdateSystemPriority, '@dcl/ecs#inputSystem');
+    function timestampIsCurrentFrame(timestamp) {
+        if (timestamp > globalState.previousFrameMaxTimestamp && timestamp <= globalState.currentFrameMaxTimestamp) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    function getClick(inputAction, entity) {
+        if (inputAction !== 3 /* InputAction.IA_ANY */) {
+            return findClick(inputAction, entity);
+        }
+        for (const input of InputCommands) {
+            const cmd = findClick(input, entity);
+            if (cmd)
+                return cmd;
+        }
+        return null;
+    }
+    function findClick(inputAction, entity) {
+        let down = null;
+        let up = null;
+        // We search the last UP & DOWN command sorted by timestamp descending
+        for (const it of findCommandsByActionDescending(inputAction, entity)) {
+            if (!up) {
+                if (it.state === 0 /* PointerEventType.PET_UP */) {
+                    up = it;
+                    continue;
+                }
+            }
+            else if (!down) {
+                if (it.state === 1 /* PointerEventType.PET_DOWN */) {
+                    down = it;
+                    break;
+                }
+            }
+        }
+        if (!up || !down)
+            return null;
+        // If the DOWN command has happen before the UP commands, it means that that a clicked has happen
+        if (down.timestamp < up.timestamp && timestampIsCurrentFrame(up.timestamp)) {
+            return { up, down };
+        }
+        return null;
+    }
+    function getInputCommandFromEntity(inputAction, pointerEventType, entity) {
+        if (inputAction !== 3 /* InputAction.IA_ANY */) {
+            return findInputCommand(inputAction, pointerEventType, entity);
+        }
+        for (const input of InputCommands) {
+            const cmd = findInputCommand(input, pointerEventType, entity);
+            if (cmd)
+                return cmd;
+        }
+        return null;
+    }
+    function getInputCommand(inputAction, pointerEventType, entity) {
+        if (entity) {
+            return getInputCommandFromEntity(inputAction, pointerEventType, entity);
+        }
+        else {
+            for (const command of globalState.thisFrameCommands) {
+                if (command.button === inputAction && command.state === pointerEventType) {
+                    return command;
+                }
+            }
+            return null;
+        }
+    }
+    function findInputCommand(inputAction, pointerEventType, entity) {
+        // We search the last pointer Event command sorted by timestamp
+        const command = findLastAction(pointerEventType, inputAction, entity);
+        if (!command)
+            return null;
+        if (timestampIsCurrentFrame(command.timestamp)) {
+            return command;
+        }
+        else {
+            return null;
+        }
+    }
+    // returns true if there was a DOWN (in any past frame), and then an UP in the last frame
+    function isClicked(inputAction, entity) {
+        return getClick(inputAction, entity) !== null;
+    }
+    // returns true if the provided last action was triggered in the last frame
+    function isTriggered(inputAction, pointerEventType, entity) {
+        if (entity) {
+            const command = findLastAction(pointerEventType, inputAction, entity);
+            return (command && timestampIsCurrentFrame(command.timestamp)) || false;
+        }
+        else {
+            for (const command of globalState.thisFrameCommands) {
+                if (command.button === inputAction && command.state === pointerEventType) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    // returns the global state of the input. This global state is updated from the system
+    function isPressed(inputAction) {
+        return globalState.buttonState.get(inputAction)?.state === 1 /* PointerEventType.PET_DOWN */;
+    }
+    return {
+        isPressed,
+        getClick,
+        getInputCommand,
+        isClicked,
+        isTriggered
+    };
+}
+exports.createInputSystem = createInputSystem;

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

@@ -0,0 +1,8 @@
+import { ISchema } from '../schemas';
+import { ByteBuffer } from '../serialization/ByteBuffer';
+import { PutComponentMessageBody, DeleteComponentMessageBody, CrdtMessageBody } from '../serialization/crdt';
+import { Entity } from './entity';
+export declare function incrementTimestamp(entity: Entity, timestamps: Map<Entity, number>): number;
+export declare function createDumpLwwFunctionFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (buffer: ByteBuffer) => void;
+export declare function createUpdateLwwFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (msg: CrdtMessageBody) => [null | PutComponentMessageBody | DeleteComponentMessageBody, any];
+export declare function createGetCrdtMessagesForLww(componentId: number, timestamps: Map<Entity, number>, dirtyIterator: Set<Entity>, schema: Pick<ISchema<any>, 'serialize'>, data: Map<Entity, unknown>): () => Generator<PutComponentMessageBody | DeleteComponentMessageBody, void, unknown>;

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentDefinitionFromSchema = exports.createGetCrdtMessagesForLww = exports.createUpdateLwwFromCrdt = exports.createDumpLwwFunctionFromCrdt = exports.incrementTimestamp = void 0;
+const ByteBuffer_1 = require("../serialization/ByteBuffer");
+const crdt_1 = require("../serialization/crdt");
+const utils_1 = require("../systems/crdt/utils");
+const readonly_1 = require("./readonly");
+function incrementTimestamp(entity, timestamps) {
+    const newTimestamp = (timestamps.get(entity) || 0) + 1;
+    timestamps.set(entity, newTimestamp);
+    return newTimestamp;
+}
+exports.incrementTimestamp = incrementTimestamp;
+function createDumpLwwFunctionFromCrdt(componentId, timestamps, schema, data) {
+    return function dumpCrdtState(buffer) {
+        for (const [entity, timestamp] of timestamps) {
+            /* istanbul ignore else */
+            if (data.has(entity)) {
+                const it = data.get(entity);
+                const buf = new ByteBuffer_1.ReadWriteByteBuffer();
+                schema.serialize(it, buf);
+                crdt_1.PutComponentOperation.write(entity, timestamp, componentId, buf.toBinary(), buffer);
+            }
+            else {
+                crdt_1.DeleteComponent.write(entity, componentId, timestamp, buffer);
+            }
+        }
+    };
+}
+exports.createDumpLwwFunctionFromCrdt = createDumpLwwFunctionFromCrdt;
+function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
+    /**
+     * Process the received message only if the lamport number recieved is higher
+     * than the stored one. If its lower, we spread it to the network to correct the peer.
+     * If they are equal, the bigger raw data wins.
+  
+      * Returns the recieved data if the lamport number was bigger than ours.
+      * If it was an outdated message, then we return void
+      * @public
+      */
+    function crdtRuleForCurrentState(message) {
+        const { entityId, timestamp } = message;
+        const currentTimestamp = timestamps.get(entityId);
+        // The received message is > than our current value, update our state.components.
+        if (currentTimestamp === undefined || currentTimestamp < timestamp) {
+            return crdt_1.ProcessMessageResultType.StateUpdatedTimestamp;
+        }
+        // Outdated Message. Resend our state message through the wire.
+        if (currentTimestamp > timestamp) {
+            // console.log('2', currentTimestamp, timestamp)
+            return crdt_1.ProcessMessageResultType.StateOutdatedTimestamp;
+        }
+        // Deletes are idempotent
+        if (message.type === crdt_1.CrdtMessageType.DELETE_COMPONENT && !data.has(entityId)) {
+            return crdt_1.ProcessMessageResultType.NoChanges;
+        }
+        let currentDataGreater = 0;
+        if (data.has(entityId)) {
+            const writeBuffer = new ByteBuffer_1.ReadWriteByteBuffer();
+            schema.serialize(data.get(entityId), writeBuffer);
+            currentDataGreater = (0, utils_1.dataCompare)(writeBuffer.toBinary(), message.data || null);
+        }
+        else {
+            currentDataGreater = (0, utils_1.dataCompare)(null, message.data);
+        }
+        // Same data, same timestamp. Weirdo echo message.
+        // console.log('3', currentDataGreater, writeBuffer.toBinary(), (message as any).data || null)
+        if (currentDataGreater === 0) {
+            return crdt_1.ProcessMessageResultType.NoChanges;
+        }
+        else if (currentDataGreater > 0) {
+            // Current data is greater
+            return crdt_1.ProcessMessageResultType.StateOutdatedData;
+        }
+        else {
+            // Curent data is lower
+            return crdt_1.ProcessMessageResultType.StateUpdatedData;
+        }
+    }
+    return (msg) => {
+        /* istanbul ignore next */
+        if (msg.type !== crdt_1.CrdtMessageType.PUT_COMPONENT && msg.type !== crdt_1.CrdtMessageType.DELETE_COMPONENT)
+            /* istanbul ignore next */
+            return [null, data.get(msg.entityId)];
+        const action = crdtRuleForCurrentState(msg);
+        const entity = msg.entityId;
+        switch (action) {
+            case crdt_1.ProcessMessageResultType.StateUpdatedData:
+            case crdt_1.ProcessMessageResultType.StateUpdatedTimestamp: {
+                timestamps.set(entity, msg.timestamp);
+                if (msg.type === crdt_1.CrdtMessageType.PUT_COMPONENT) {
+                    const buf = new ByteBuffer_1.ReadWriteByteBuffer(msg.data);
+                    data.set(entity, schema.deserialize(buf));
+                }
+                else {
+                    data.delete(entity);
+                }
+                return [null, data.get(entity)];
+            }
+            case crdt_1.ProcessMessageResultType.StateOutdatedTimestamp:
+            case crdt_1.ProcessMessageResultType.StateOutdatedData: {
+                if (data.has(entity)) {
+                    const writeBuffer = new ByteBuffer_1.ReadWriteByteBuffer();
+                    schema.serialize(data.get(entity), writeBuffer);
+                    return [
+                        {
+                            type: crdt_1.CrdtMessageType.PUT_COMPONENT,
+                            componentId,
+                            data: writeBuffer.toBinary(),
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        data.get(entity)
+                    ];
+                }
+                else {
+                    return [
+                        {
+                            type: crdt_1.CrdtMessageType.DELETE_COMPONENT,
+                            componentId,
+                            entityId: entity,
+                            timestamp: timestamps.get(entity)
+                        },
+                        undefined
+                    ];
+                }
+            }
+        }
+        return [null, data.get(entity)];
+    };
+}
+exports.createUpdateLwwFromCrdt = createUpdateLwwFromCrdt;
+function createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data) {
+    return function* () {
+        for (const entity of dirtyIterator) {
+            const newTimestamp = incrementTimestamp(entity, timestamps);
+            if (data.has(entity)) {
+                const writeBuffer = new ByteBuffer_1.ReadWriteByteBuffer();
+                schema.serialize(data.get(entity), writeBuffer);
+                const msg = {
+                    type: crdt_1.CrdtMessageType.PUT_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    data: writeBuffer.toBinary(),
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+            else {
+                const msg = {
+                    type: crdt_1.CrdtMessageType.DELETE_COMPONENT,
+                    componentId,
+                    entityId: entity,
+                    timestamp: newTimestamp
+                };
+                yield msg;
+            }
+        }
+        dirtyIterator.clear();
+    };
+}
+exports.createGetCrdtMessagesForLww = createGetCrdtMessagesForLww;
+/**
+ * @internal
+ */
+function createComponentDefinitionFromSchema(componentName, componentId, schema) {
+    const data = new Map();
+    const dirtyIterator = new Set();
+    const timestamps = new Map();
+    return {
+        get componentId() {
+            return componentId;
+        },
+        get componentName() {
+            return componentName;
+        },
+        get componentType() {
+            // a getter is used here to prevent accidental changes
+            return 0 /* ComponentType.LastWriteWinElementSet */;
+        },
+        schema,
+        has(entity) {
+            return data.has(entity);
+        },
+        deleteFrom(entity, markAsDirty = true) {
+            const component = data.get(entity);
+            if (data.delete(entity) && markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+            return component || null;
+        },
+        entityDeleted(entity, markAsDirty) {
+            if (data.delete(entity) && markAsDirty) {
+                dirtyIterator.add(entity);
+            }
+        },
+        getOrNull(entity) {
+            const component = data.get(entity);
+            return component ? (0, readonly_1.deepReadonly)(component) : null;
+        },
+        get(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[getFrom] Component ${componentName} for entity #${entity} not found`);
+            }
+            return (0, readonly_1.deepReadonly)(component);
+        },
+        create(entity, value) {
+            const component = data.get(entity);
+            if (component) {
+                throw new Error(`[create] Component ${componentName} for ${entity} already exists`);
+            }
+            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        createOrReplace(entity, value) {
+            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        getMutableOrNull(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                return null;
+            }
+            dirtyIterator.add(entity);
+            return component;
+        },
+        getOrCreateMutable(entity, value) {
+            const component = data.get(entity);
+            if (!component) {
+                return this.create(entity, value);
+            }
+            else {
+                dirtyIterator.add(entity);
+                return component;
+            }
+        },
+        getMutable(entity) {
+            const component = this.getMutableOrNull(entity);
+            if (component === null) {
+                throw new Error(`[mutable] Component ${componentName} for ${entity} not found`);
+            }
+            return component;
+        },
+        *iterator() {
+            for (const [entity, component] of data) {
+                yield [entity, component];
+            }
+        },
+        *dirtyIterator() {
+            for (const entity of dirtyIterator) {
+                yield entity;
+            }
+        },
+        getCrdtUpdates: createGetCrdtMessagesForLww(componentId, timestamps, dirtyIterator, schema, data),
+        updateFromCrdt: createUpdateLwwFromCrdt(componentId, timestamps, schema, data),
+        dumpCrdtStateToBuffer: createDumpLwwFunctionFromCrdt(componentId, timestamps, schema, data)
+    };
+}
+exports.createComponentDefinitionFromSchema = createComponentDefinitionFromSchema;

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

@@ -0,0 +1,29 @@
+import { ComponentDefinition } from './component';
+/**
+ * @public
+ */
+export type DeepReadonlyMap<K, V> = ReadonlyMap<K, DeepReadonly<V>>;
+/**
+ * @public
+ */
+export type DeepReadonlySet<T> = ReadonlySet<DeepReadonly<T>>;
+/**
+ * @public
+ */
+export type DeepReadonlyObject<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+/**
+ * @public
+ */
+export type ReadonlyPrimitive = number | string | number[] | string[] | boolean | boolean[];
+/**
+ * @public
+ */
+export type ReadonlyComponentSchema<T extends [ComponentDefinition<unknown>, ...ComponentDefinition<unknown>[]]> = {
+    [K in keyof T]: T[K] extends ComponentDefinition<unknown> ? ReturnType<T[K]['get']> : never;
+};
+/**
+ * @public
+ */
+export type DeepReadonly<T> = T extends ReadonlyPrimitive ? T : T extends Array<infer K> ? ReadonlyArray<DeepReadonly<K>> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;

package/dist-cjs/engine/readonly.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepReadonly = void 0;
+/**
+ * @internal
+ */
+function deepReadonly(val) {
+    return Object.freeze({ ...val });
+}
+exports.deepReadonly = deepReadonly;

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

@@ -0,0 +1,15 @@
+/**
+ * @public
+ */
+export type SystemFn = (dt: number) => void;
+export declare const SYSTEMS_REGULAR_PRIORITY = 100000;
+export type SystemItem = {
+    fn: SystemFn;
+    priority: number;
+    name?: string;
+};
+export declare function SystemContainer(): {
+    add: (fn: SystemFn, priority: number, name?: string) => void;
+    remove: (selector: string | SystemFn) => boolean;
+    getSystems(): SystemItem[];
+};

package/dist-cjs/engine/systems.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemContainer = exports.SYSTEMS_REGULAR_PRIORITY = void 0;
+exports.SYSTEMS_REGULAR_PRIORITY = 100e3;
+function SystemContainer() {
+    const systems = [];
+    function sort() {
+        // TODO: systems with the same priority should always have the same stable order
+        //       add a "counter" to the System type to ensure that order
+        systems.sort((a, b) => b.priority - a.priority);
+    }
+    function add(fn, priority, name) {
+        const systemName = name ?? fn.name;
+        if (systems.find((item) => item.fn === fn)) {
+            throw new Error(`System ${JSON.stringify(systemName)} already added to the engine`);
+        }
+        systems.push({
+            fn,
+            priority,
+            name: systemName
+        });
+        // TODO: replace this sort by an insertion in the right place
+        sort();
+    }
+    function remove(selector) {
+        let index = -1;
+        if (typeof selector === 'string') {
+            index = systems.findIndex((item) => item.name === selector);
+        }
+        else {
+            index = systems.findIndex((item) => item.fn === selector);
+        }
+        if (index === -1) {
+            return false;
+        }
+        systems.splice(index, 1);
+        sort();
+        return true;
+    }
+    return {
+        add,
+        remove,
+        getSystems() {
+            return systems;
+        }
+    };
+}
+exports.SystemContainer = SystemContainer;