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

package/dist/engine/input.d.ts

@@ -0,0 +1,36 @@
+import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
+import { PointerEventType } from '../components/generated/pb/decentraland/sdk/components/pointer_hover_feedback.gen';
+import { PBPointerEventsResult_PointerCommand } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+import { Entity } from './entity';
+import { IEngine } from './types';
+/**
+ * @public
+ */
+export declare 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_PointerCommand | null;
+};
+export declare function createInputSystem(engine: IEngine): IInputSystem;

package/dist/engine/input.js

@@ -0,0 +1,156 @@
+import * as components from '../components';
+import { Schemas } from '../schemas';
+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 InternalInputStateSchema = {
+    timestampLastUpdate: Schemas.Number,
+    currentTimestamp: Schemas.Number,
+    buttonState: Schemas.Array(Schemas.Map({
+        value: Schemas.Boolean,
+        ts: Schemas.Number
+    }))
+};
+const InternalInputStateComponentId = 1500;
+const TimestampUpdateSystemPriority = 1 << 20;
+const ButtonStateUpdateSystemPriority = 0;
+export function createInputSystem(engine) {
+    const PointerEventsResult = components.PointerEventsResult(engine);
+    const InternalInputStateComponent = engine.defineComponent(InternalInputStateSchema, InternalInputStateComponentId);
+    InternalInputStateComponent.create(engine.RootEntity, {
+        buttonState: Array.from({ length: InputCommands.length }, () => ({
+            ts: 0,
+            value: false
+        }))
+    });
+    function timestampUpdateSystem() {
+        const state = InternalInputStateComponent.get(engine.RootEntity);
+        if (state.currentTimestamp > state.timestampLastUpdate) {
+            InternalInputStateComponent.getMutable(engine.RootEntity).timestampLastUpdate = state.currentTimestamp;
+        }
+    }
+    function buttonStateUpdateSystem() {
+        const component = PointerEventsResult.getOrNull(engine.RootEntity);
+        if (!component)
+            return;
+        const state = InternalInputStateComponent.getMutable(engine.RootEntity);
+        for (const command of component.commands) {
+            if (command.timestamp > state.buttonState[command.button].ts) {
+                if (command.state === 1 /* PointerEventType.PET_DOWN */) {
+                    state.buttonState[command.button].value = true;
+                }
+                else if (command.state === 0 /* PointerEventType.PET_UP */) {
+                    state.buttonState[command.button].value = false;
+                }
+            }
+        }
+    }
+    engine.addSystem(buttonStateUpdateSystem, ButtonStateUpdateSystemPriority, '@dcl/ecs#buttonStateUpdateSystem');
+    engine.addSystem(timestampUpdateSystem, TimestampUpdateSystemPriority, '@dcl/ecs#timestampUpdateSystem');
+    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) {
+        const component = PointerEventsResult.getOrNull(engine.RootEntity);
+        if (!component)
+            return null;
+        const commands = component.commands;
+        // We search the last DOWN command sorted by timestamp
+        const down = findLastAction(commands, 1 /* PointerEventType.PET_DOWN */, inputAction, entity);
+        // We search the last UP command sorted by timestamp
+        if (!down)
+            return null;
+        const up = findLastAction(commands, 0 /* PointerEventType.PET_UP */, inputAction, entity);
+        if (!up)
+            return null;
+        const state = InternalInputStateComponent.get(engine.RootEntity);
+        // If the DOWN command has happen before the UP commands, it means that that a clicked has happen
+        if (down.timestamp < up.timestamp &&
+            up.timestamp > state.timestampLastUpdate) {
+            InternalInputStateComponent.getMutable(engine.RootEntity).currentTimestamp = Math.max(up.timestamp, state.currentTimestamp);
+            return { up, down };
+        }
+        return null;
+    }
+    function getInputCommand(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 findInputCommand(inputAction, pointerEventType, entity) {
+        const component = PointerEventsResult.getOrNull(engine.RootEntity);
+        if (!component)
+            return null;
+        // We search the last pointer Event command sorted by timestamp
+        const command = findLastAction(component.commands, pointerEventType, inputAction, entity);
+        if (!command)
+            return null;
+        const state = InternalInputStateComponent.get(engine.RootEntity);
+        if (command.timestamp > state.timestampLastUpdate) {
+            InternalInputStateComponent.getMutable(engine.RootEntity).currentTimestamp = Math.max(command.timestamp, state.currentTimestamp);
+            return command;
+        }
+        else {
+            return null;
+        }
+    }
+    function isClicked(inputAction, entity) {
+        return getClick(inputAction, entity) !== null;
+    }
+    function isTriggered(inputAction, pointerEventType, entity) {
+        return getInputCommand(inputAction, pointerEventType, entity) !== null;
+    }
+    function isPressed(inputAction) {
+        return InternalInputStateComponent.get(engine.RootEntity).buttonState[inputAction].value;
+    }
+    return {
+        // @public
+        isPressed,
+        // @internal
+        getClick,
+        // @public
+        getInputCommand,
+        // @internal
+        isClicked,
+        // @public
+        isTriggered
+    };
+}
+function findLastAction(commands, pointerEventType, inputAction, entity) {
+    let commandToReturn = undefined;
+    for (const command of commands) {
+        if (command.button === inputAction &&
+            command.state === pointerEventType &&
+            (!entity || (command.hit && entity === command.hit.entityId))) {
+            if (!commandToReturn || command.timestamp >= commandToReturn.timestamp)
+                commandToReturn = command;
+        }
+    }
+    return commandToReturn;
+}

package/dist/engine/readonly.d.ts

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

package/dist/engine/readonly.js

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ */
+export function deepReadonly(val) {
+    return Object.freeze({ ...val });
+}

package/dist/engine/systems.d.ts

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

package/dist/engine/systems.js

@@ -0,0 +1,44 @@
+export const SYSTEMS_REGULAR_PRIORITY = 100e3;
+export 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;
+        }
+    };
+}

package/dist/engine/types.d.ts

@@ -0,0 +1,148 @@
+import type { ISchema } from '../schemas/ISchema';
+import { Result, Spec } from '../schemas/Map';
+import { Transport } from '../systems/crdt/types';
+import { ComponentDefinition as CompDef } from './component';
+import { Entity } from './entity';
+import { SystemFn } from './systems';
+import { ReadonlyComponentSchema } from './readonly';
+export { ISchema } from '../schemas/ISchema';
+/**
+ * @public
+ */
+export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
+/**
+ * @public
+ */
+export declare type ComponentSchema<T extends [CompDef<any>, ...CompDef<any>[]]> = {
+    [K in keyof T]: T[K] extends CompDef<any> ? ReturnType<T[K]['getMutable']> : never;
+};
+/**
+ * @public
+ */
+export declare type IEngine = {
+    /**
+     * Increment the used entity counter and return the next one.
+     * @param dynamic - whether or no the entity should be considered as Dynamic (vs Static)
+     * @returns the next entity unused
+     */
+    addEntity(dynamic?: boolean): Entity;
+    /**
+     * An alias of engine.addEntity(true)
+     */
+    addDynamicEntity(): Entity;
+    /**
+     * Remove all components of an entity
+     * @param entity - entity
+     */
+    removeEntity(entity: Entity): void;
+    /**
+     * Remove all components of each entity in the tree made with Transform parenting
+     * @param firstEntity - the root entity of the tree
+     */
+    removeEntityWithChildren(firstEntity: Entity): void;
+    /**
+     * Check if an entity exists in the engine
+     * @param entity - the entity to validate
+     * @returns true if the entity exists in the engine
+     */
+    entityExists(entity: Entity): boolean;
+    /**
+     * 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.
+     * @param priority - a number with the priority, big number are called before smaller ones
+     * @param name - optional: a unique name to identify it
+     *
+     * Example:
+     * ```ts
+     * function mySystem(dt: number) {
+     *   const entitiesWithMeshRenderer = engine.getEntitiesWith(MeshRenderer, Transform)
+     *   for (const [entity, _meshRenderer, _transform] of engine.getEntitiesWith(MeshRenderer, Transform)) {
+     *     // do stuffs
+     *   }
+     * }
+     * engine.addSystem(mySystem, 10)
+     * ```
+     */
+    addSystem(system: SystemFn, priority?: number, name?: string): void;
+    /**
+     * Remove a system from the engine.
+     * @param selector - the function or the unique name to identify
+     * @returns if it was found and removed
+     */
+    removeSystem(selector: string | SystemFn): boolean;
+    /**
+     * Define a component and add it to the engine.
+     * @param spec - An object with schema fields
+     * @param componentId - unique id to identify the component, if the component id already exist, it will fail.
+     * @param constructorDefault - the initial value prefilled when a component is created without a value
+     * @returns The component definition
+     *
+     * ```ts
+     * const DoorComponentId = 10017
+     * const Door = engine.defineComponent({
+     *   id: Schemas.Int,
+     *   name: Schemas.String
+     * }, DoorComponentId)
+     *
+     * ```
+     */
+    defineComponent<T extends Spec, ConstructorType = Partial<Result<T>>>(spec: T, componentId: number, constructorDefault?: ConstructorType): CompDef<ISchema<Result<T>>, Partial<Result<T>>>;
+    /**
+     * Define a component and add it to the engine.
+     * @param spec - An object with schema fields
+     * @param componentId - unique id to identify the component, if the component id already exist, it will fail.
+     * @returns The component definition
+     *
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.defineComponent(Schemas.Bool, VisibleComponentId)
+     * ```
+     */
+    defineComponentFromSchema<T extends ISchema<ConstructorType>, ConstructorType>(spec: T, componentId: number, constructorDefault?: ConstructorType): CompDef<T, ConstructorType>;
+    /**
+     * Get the component definition from the component id.
+     * @param componentId - component number used to identify the component descriptor
+     * @returns the component definition, throw an error if it doesn't exist
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.getComponent(StateComponentId)
+     * ```
+     */
+    getComponent<T extends ISchema>(componentId: number): CompDef<T>;
+    /**
+     * Get a iterator of entities that has all the component requested.
+     * @param components - a list of component definitions
+     * @returns An iterator of an array with the [entity, component1, component2, ...]
+     *
+     * Example:
+     * ```ts
+     * for (const [entity, meshRenderer, transform] of engine.getEntitiesWith(MeshRenderer, Transform)) {
+     *   // the properties of meshRenderer and transform are read only
+     * }
+     * ```
+     */
+    getEntitiesWith<T extends [CompDef<any>, ...CompDef<any>[]]>(...components: T): Iterable<[Entity, ...ReadonlyComponentSchema<T>]>;
+    /**
+     * @param deltaTime - deltaTime in seconds
+     */
+    update(deltaTime: number): void;
+    /**
+     * @public
+     * Refer to the root of the scene, all Transforms without a parent are parenting with RootEntity.
+     */
+    readonly RootEntity: Entity;
+    /**
+     * @public
+     * The current player entity
+     */
+    readonly PlayerEntity: Entity;
+    /**
+     * @public
+     * Camera entity of current player.
+     */
+    readonly CameraEntity: Entity;
+    /**
+     * @param transport - transport which changes its onmessage to process CRDT messages
+     */
+    addTransport(transport: Transport): void;
+};

package/dist/engine/types.js

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