@dcl/ecs 7.0.0-3532389879.commit-c89c80c → 7.0.0-3568547351.commit-5420eac

package/dist/systems/crdt/index.js

@@ -0,0 +1,169 @@
+import { crdtProtocol } from '@dcl/crdt';
+import { createByteBuffer } from '../../serialization/ByteBuffer';
+import { ComponentOperation as Message } from '../../serialization/crdt/componentOperation';
+import WireMessage from '../../serialization/wireMessage';
+export function crdtSceneSystem(engine) {
+    const transports = [];
+    // CRDT Client
+    const crdtClient = crdtProtocol();
+    // Messages that we received at transport.onMessage waiting to be processed
+    const receivedMessages = [];
+    // Messages already processed by the engine but that we need to broadcast to other transports.
+    const transportMessages = [];
+    // Map of entities already processed at least once
+    /**
+     *
+     * @param transportType tranport id to identiy messages
+     * @returns a function to process received messages
+     */
+    function parseChunkMessage(transportType) {
+        /**
+         * Receives a chunk of binary messages and stores all the valid
+         * Component Operation Messages at messages queue
+         * @param chunkMessage A chunk of binary messages
+         */
+        return function parseChunkMessage(chunkMessage) {
+            const buffer = createByteBuffer({
+                reading: { buffer: chunkMessage, currentOffset: 0 }
+            });
+            while (WireMessage.validate(buffer)) {
+                const offset = buffer.currentReadOffset();
+                const message = Message.read(buffer);
+                const { type, entity, componentId, data, timestamp } = message;
+                receivedMessages.push({
+                    type,
+                    entity,
+                    componentId,
+                    data,
+                    timestamp,
+                    transportType,
+                    messageBuffer: buffer
+                        .buffer()
+                        .subarray(offset, buffer.currentReadOffset())
+                });
+            }
+            // TODO: do something if buffler.len>0
+        };
+    }
+    /**
+     * Return and clear the messaes queue
+     * @returns messages recieved by the transport to process on the next tick
+     */
+    function getMessages(value) {
+        const messagesToProcess = Array.from(value);
+        value.length = 0;
+        return messagesToProcess;
+    }
+    /**
+     * This fn will be called on every tick.
+     * Process all the messages queue received by the transport
+     */
+    function receiveMessages() {
+        const messagesToProcess = getMessages(receivedMessages);
+        for (const transport of transports) {
+            const buffer = createByteBuffer();
+            for (const message of messagesToProcess) {
+                const { data, timestamp, componentId, entity, type } = message;
+                const crdtMessage = {
+                    key1: entity,
+                    key2: componentId,
+                    data: data || null,
+                    timestamp: timestamp
+                };
+                const component = engine.getComponent(componentId);
+                const current = crdtClient.processMessage(crdtMessage);
+                // CRDT outdated message. Resend this message through the wire
+                if (crdtMessage !== current) {
+                    const type = component.has(entity)
+                        ? WireMessage.Enum.PUT_COMPONENT
+                        : WireMessage.Enum.DELETE_COMPONENT;
+                    Message.write(type, entity, current.timestamp, component, buffer);
+                }
+                else {
+                    // Process CRDT Message
+                    if (type === WireMessage.Enum.DELETE_COMPONENT) {
+                        component.deleteFrom(entity);
+                    }
+                    else {
+                        const opts = {
+                            reading: { buffer: message.data, currentOffset: 0 }
+                        };
+                        const bb = createByteBuffer(opts);
+                        // Update engine component
+                        component.upsertFromBinary(message.entity, bb);
+                        component.clearDirty();
+                    }
+                    // Add message to transport queue to be processed by others transports
+                    transportMessages.push(message);
+                }
+            }
+            if (buffer.size()) {
+                transport.send(buffer.toBinary());
+            }
+        }
+    }
+    /**
+     * Iterates the dirty map and generates crdt messages to be send
+     * @param dirtyMap a map of { entities: [componentId] }
+     */
+    function createMessages(dirtyMap) {
+        // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
+        const crdtMessages = getMessages(transportMessages);
+        const buffer = createByteBuffer();
+        for (const [entity, componentsId] of dirtyMap) {
+            for (const componentId of componentsId) {
+                const component = engine.getComponent(componentId);
+                const entityComponent = component.has(entity)
+                    ? component.toBinary(entity).toBinary()
+                    : null;
+                const event = crdtClient.createEvent(entity, componentId, entityComponent);
+                const offset = buffer.currentWriteOffset();
+                const type = component.has(entity)
+                    ? WireMessage.Enum.PUT_COMPONENT
+                    : WireMessage.Enum.DELETE_COMPONENT;
+                const transportMessage = {
+                    type,
+                    componentId,
+                    entity,
+                    timestamp: event.timestamp
+                };
+                if (transports.some((t) => t.filter(transportMessage))) {
+                    Message.write(type, entity, event.timestamp, component, buffer);
+                    crdtMessages.push({
+                        ...transportMessage,
+                        messageBuffer: buffer
+                            .buffer()
+                            .subarray(offset, buffer.currentWriteOffset())
+                    });
+                }
+            }
+        }
+        // Send messages to transports
+        const transportBuffer = createByteBuffer();
+        for (const transport of transports) {
+            transportBuffer.resetBuffer();
+            for (const message of crdtMessages) {
+                if (transport.filter(message)) {
+                    transportBuffer.writeBuffer(message.messageBuffer, false);
+                }
+            }
+            if (transportBuffer.size()) {
+                transport.send(transportBuffer.toBinary());
+            }
+            else {
+                transport.send(new Uint8Array([]));
+            }
+        }
+    }
+    function addTransport(transport) {
+        transports.push(transport);
+        transport.onmessage = parseChunkMessage(transport.type);
+        // TODO: pull messages from transport
+        // TODO: send entities to transport
+    }
+    return {
+        createMessages,
+        receiveMessages,
+        addTransport
+    };
+}

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

@@ -0,0 +1,18 @@
+import { Entity } from '../../engine/entity';
+import WireMessage from '../../serialization/wireMessage';
+export declare type ReceiveMessage = {
+    type: WireMessage.Enum;
+    entity: Entity;
+    componentId: number;
+    timestamp: number;
+    transportType?: string;
+    data?: Uint8Array;
+    messageBuffer: Uint8Array;
+};
+export declare type TransportMessage = Omit<ReceiveMessage, 'data'>;
+export declare type Transport = {
+    type: string;
+    send(message: Uint8Array): void;
+    onmessage?(message: Uint8Array): void;
+    filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
+};

package/dist/systems/crdt/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import { ComponentDefinition } from '../../engine/component';
+export declare namespace CrdtUtils {
+    type ComponentID = ComponentDefinition<any>['_id'];
+    enum SynchronizedEntityType {
+        NETWORKED = 0,
+        RENDERER = 1
+    }
+}
+export default CrdtUtils;

package/dist/systems/crdt/utils.js

@@ -0,0 +1,11 @@
+export var CrdtUtils;
+(function (CrdtUtils) {
+    let SynchronizedEntityType;
+    (function (SynchronizedEntityType) {
+        // synchronizes entities with the NetworkSynchronized component only, used for networked games
+        SynchronizedEntityType[SynchronizedEntityType["NETWORKED"] = 0] = "NETWORKED";
+        // synchronizes entities needed by the renderer
+        SynchronizedEntityType[SynchronizedEntityType["RENDERER"] = 1] = "RENDERER";
+    })(SynchronizedEntityType = CrdtUtils.SynchronizedEntityType || (CrdtUtils.SynchronizedEntityType = {}));
+})(CrdtUtils || (CrdtUtils = {}));
+export default CrdtUtils;

package/dist/systems/cyclicParentingChecker.d.ts

@@ -0,0 +1,17 @@
+import { IEngine } from '../engine/types';
+/**
+ * Transform parenting: cyclic dependency checker
+ * It checks only in modified Transforms
+ *
+ * Add this system with:
+ * ```ts
+ *  engine.addSystem(cyclicParentingChecker(engine))
+ * ````
+ * And then it will check every tick the parenting.
+ *
+ * @public
+ *
+ * @params engine
+ * @returns a system
+ */
+export declare function cyclicParentingChecker(engine: IEngine): () => void;

package/dist/systems/cyclicParentingChecker.js

@@ -0,0 +1,33 @@
+import * as components from '../components';
+/**
+ * Transform parenting: cyclic dependency checker
+ * It checks only in modified Transforms
+ *
+ * Add this system with:
+ * ```ts
+ *  engine.addSystem(cyclicParentingChecker(engine))
+ * ````
+ * And then it will check every tick the parenting.
+ *
+ * @public
+ *
+ * @params engine
+ * @returns a system
+ */
+export function cyclicParentingChecker(engine) {
+    const Transform = components.Transform(engine);
+    return () => {
+        for (const entity of Transform.dirtyIterator()) {
+            let transform = Transform.getOrNull(entity);
+            while (transform && transform.parent) {
+                if (transform.parent === entity) {
+                    console.error(`There is a cyclic parent with entity ${entity}`);
+                    break;
+                }
+                else {
+                    transform = Transform.getOrNull(transform.parent);
+                }
+            }
+        }
+    };
+}

package/dist/systems/events.d.ts

@@ -0,0 +1,56 @@
+import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
+import { PBPointerEventsResult_PointerCommand } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+import { IEngine } from '../engine/types';
+import { Entity } from '../engine/entity';
+import { IInputSystem } from '../engine/input';
+export declare type EventSystemCallback = (event: PBPointerEventsResult_PointerCommand) => void;
+export declare type EventSystemOptions = {
+    button?: InputAction;
+    hoverText?: string;
+    maxDistance?: number;
+};
+export declare type PointerEventsSystem = ReturnType<typeof createPointerEventSystem>;
+export declare function createPointerEventSystem(engine: IEngine, inputSystem: IInputSystem): {
+    /**
+     * @internal
+     * Remove the callback for onClick event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnClick(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDown event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDown(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerUp event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerUp(entity: Entity): void;
+    /**
+     * @internal
+     * Execute callback when the user clicks the entity.
+     * @param entity - Entity to attach the callback
+     * @param cb - Function to execute when onPointerDown fires
+     * @param opts - Opts to trigger Feedback and Button
+     */
+    onClick(entity: Entity, cb: EventSystemCallback, opts?: EventSystemOptions): void;
+    /**
+     * @public
+     * Execute callback when the user press the InputButton pointing at the entity
+     * @param entity - Entity to attach the callback
+     * @param cb - Function to execute when click fires
+     * @param opts - Opts to trigger Feedback and Button
+     */
+    onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: EventSystemOptions): void;
+    /**
+     * @public
+     * Execute callback when the user releases the InputButton pointing at the entity
+     * @param entity - Entity to attach the callback
+     * @param cb - Function to execute when click fires
+     * @param opts - Opts to trigger Feedback and Button
+     */
+    onPointerUp(entity: Entity, cb: EventSystemCallback, opts?: EventSystemOptions): void;
+};

package/dist/systems/events.js

@@ -0,0 +1,145 @@
+import * as components from '../components';
+import { checkNotThenable } from '../runtime/invariant';
+export function createPointerEventSystem(engine, inputSystem) {
+    const PointerHoverFeedback = components.PointerHoverFeedback(engine);
+    let EventType;
+    (function (EventType) {
+        EventType[EventType["Click"] = 0] = "Click";
+        EventType[EventType["Down"] = 1] = "Down";
+        EventType[EventType["Up"] = 2] = "Up";
+    })(EventType || (EventType = {}));
+    const getDefaultOpts = (opts = {}) => ({
+        button: 3 /* InputAction.IA_ANY */,
+        hoverText: 'Interact',
+        maxDistance: 100,
+        ...opts
+    });
+    const eventsMap = new Map();
+    function getEvent(entity) {
+        return (eventsMap.get(entity) || eventsMap.set(entity, new Map()).get(entity));
+    }
+    function setHoverFeedback(entity, type, opts) {
+        if (opts.hoverText) {
+            const pointerEvent = PointerHoverFeedback.getMutableOrNull(entity) ||
+                PointerHoverFeedback.create(entity);
+            pointerEvent.pointerEvents.push({
+                eventType: type,
+                eventInfo: {
+                    button: opts.button,
+                    showFeedback: true,
+                    hoverText: opts.hoverText,
+                    maxDistance: opts.maxDistance
+                }
+            });
+        }
+    }
+    function removeHoverFeedback(entity, type, button) {
+        const pointerEvent = PointerHoverFeedback.getMutableOrNull(entity);
+        if (!pointerEvent)
+            return;
+        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button && pointer.eventType === type));
+    }
+    function getPointerEvent(eventType) {
+        if (eventType === EventType.Up) {
+            return 0 /* PointerEventType.PET_UP */;
+        }
+        return 1 /* PointerEventType.PET_DOWN */;
+    }
+    function removeEvent(entity, type) {
+        const event = getEvent(entity);
+        const pointerEvent = event.get(type);
+        if (pointerEvent?.opts.hoverText) {
+            removeHoverFeedback(entity, getPointerEvent(type), pointerEvent.opts.button);
+        }
+        event.delete(type);
+    }
+    // @internal
+    engine.addSystem(function EventSystem() {
+        for (const [entity, event] of eventsMap) {
+            if (!engine.entityExists(entity)) {
+                eventsMap.delete(entity);
+                continue;
+            }
+            for (const [eventType, { cb, opts }] of event) {
+                if (eventType === EventType.Click) {
+                    const command = inputSystem.getClick(opts.button, entity);
+                    if (command)
+                        checkNotThenable(cb(command.up), 'Click event returned a thenable. Only synchronous functions are allowed');
+                }
+                if (eventType === EventType.Down || eventType === EventType.Up) {
+                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
+                    if (command) {
+                        checkNotThenable(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                    }
+                }
+            }
+        }
+    });
+    return {
+        /**
+         * @internal
+         * Remove the callback for onClick event
+         * @param entity - Entity where the callback was attached
+         */
+        removeOnClick(entity) {
+            removeEvent(entity, EventType.Click);
+        },
+        /**
+         * @public
+         * Remove the callback for onPointerDown event
+         * @param entity - Entity where the callback was attached
+         */
+        removeOnPointerDown(entity) {
+            removeEvent(entity, EventType.Down);
+        },
+        /**
+         * @public
+         * Remove the callback for onPointerUp event
+         * @param entity - Entity where the callback was attached
+         */
+        removeOnPointerUp(entity) {
+            removeEvent(entity, EventType.Up);
+        },
+        /**
+         * @internal
+         * Execute callback when the user clicks the entity.
+         * @param entity - Entity to attach the callback
+         * @param cb - Function to execute when onPointerDown fires
+         * @param opts - Opts to trigger Feedback and Button
+         */
+        onClick(entity, cb, opts) {
+            const options = getDefaultOpts(opts);
+            // Clear previous event with over feedback included
+            removeEvent(entity, EventType.Click);
+            // Set new event
+            getEvent(entity).set(EventType.Click, { cb, opts: options });
+            setHoverFeedback(entity, 1 /* PointerEventType.PET_DOWN */, options);
+        },
+        /**
+         * @public
+         * Execute callback when the user press the InputButton pointing at the entity
+         * @param entity - Entity to attach the callback
+         * @param cb - Function to execute when click fires
+         * @param opts - Opts to trigger Feedback and Button
+         */
+        onPointerDown(entity, cb, opts) {
+            const options = getDefaultOpts(opts);
+            removeEvent(entity, EventType.Down);
+            getEvent(entity).set(EventType.Down, { cb, opts: options });
+            setHoverFeedback(entity, 1 /* PointerEventType.PET_DOWN */, options);
+        },
+        /**
+         * @public
+         * Execute callback when the user releases the InputButton pointing at the entity
+         * @param entity - Entity to attach the callback
+         * @param cb - Function to execute when click fires
+         * @param opts - Opts to trigger Feedback and Button
+         */
+        onPointerUp(entity, cb, opts) {
+            const options = getDefaultOpts(opts);
+            removeEvent(entity, EventType.Up);
+            getEvent(entity).set(EventType.Up, { cb, opts: options });
+            setHoverFeedback(entity, 0 /* PointerEventType.PET_UP */, options);
+        }
+    };
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.0-3532389879.commit-c89c80c",
+  "version": "7.0.0-3568547351.commit-5420eac",
   "description": "Decentraland ECS",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "./../dcl-rollup/node_modules/.bin/rollup -c ./../dcl-rollup/dist/ecs.config.js"
+    "build": "tsc -p tsconfig.json"
   },
   "repository": {
     "type": "git",
@@ -23,22 +24,16 @@
   },
   "homepage": "https://github.com/decentraland/ecs#readme",
   "devDependencies": {
-    "@types/fs-extra": "^9.0.13",
-    "fs-extra": "^10.1.0",
     "ts-proto": "^1.112.0"
   },
   "dependencies": {
     "@dcl/crdt": "^1.0.0-20220819145912.commit-35069cd",
-    "@dcl/ecs-math": "^2.0.1-20221108141807.commit-a1344cb",
-    "@dcl/posix": "^1.0.4",
+    "@dcl/js-runtime": "file:../js-runtime",
     "@dcl/protocol": "^1.0.0-3524279049.commit-02b9080"
   },
   "files": [
-    "dist/index.js",
-    "dist/index.d.ts",
-    "dist/index.min.js",
-    "dist/index.min.js.map",
-    "proto-definitions"
+    "dist",
+    "etc"
   ],
-  "commit": "c89c80c3172f4a3ccbc191441f4c4a7b3fe06ac9"
+  "commit": "5420eac2bc4215f214136d8b1331864a19118824"
 }