@dcl/ecs 7.24.5-29247185020.commit-e92dfe6 → 7.24.5-29264961047.commit-77493c3

package/dist-cjs/runtime/helpers/timers.js

@@ -23,47 +23,59 @@ exports.createTimers = void 0;
 function createTimers(targetEngine) {
     const timers = new Map();
     let timerIdCounter = 0;
+    // While a timer's callback is running this holds the time already consumed this
+    // frame before that timer's logical fire instant (`elapsedMs - residualMs`);
+    // `null` otherwise. A timer armed from within the callback is seeded with the
+    // negative of this, so its delay is measured from the parent's fire instant
+    // rather than from the start of the frame.
+    let armContext = null;
     function system(dt) {
+        const elapsedMs = 1000 * dt;
         for (const [timerId, timerData] of timers) {
-            timerData.accumulatedTime += 1000 * dt;
+            timerData.accumulatedTime += elapsedMs;
             if (timerData.accumulatedTime < timerData.interval) {
                 continue;
             }
+            // Time elapsed past this timer's logical fire instant this frame.
+            const residualMs = timerData.recurrent
+                ? timerData.accumulatedTime % timerData.interval
+                : timerData.accumulatedTime - timerData.interval;
             if (timerData.recurrent) {
-                // For intervals, subtract full interval periods to handle accumulated time
-                const fullIntervals = Math.floor(timerData.accumulatedTime / timerData.interval);
-                timerData.accumulatedTime -= fullIntervals * timerData.interval;
+                // Collapse any missed periods into a single callback, keep the remainder.
+                timerData.accumulatedTime = residualMs;
             }
             else {
                 timers.delete(timerId);
             }
+            armContext = { accruedMs: elapsedMs - residualMs };
             timerData.callback();
+            armContext = null;
         }
     }
     targetEngine.addSystem(system, Number.MAX_SAFE_INTEGER, '@dcl/ecs/timers');
+    function addTimer(callback, interval, recurrent) {
+        const timerId = timerIdCounter++;
+        let accumulatedTime = 0;
+        if (armContext) {
+            // Armed from inside a firing callback: this timer is appended to the map
+            // being iterated, so the loop will still add this frame's elapsed to it.
+            // Inherit the residual so that `+= elapsedMs` nets to the true time
+            // elapsed since the parent fired (phase-accurate). Each successive arming
+            // starts one interval lower, so a re-arming chain terminates this frame.
+            accumulatedTime = -armContext.accruedMs;
+        }
+        timers.set(timerId, { callback, interval, recurrent, accumulatedTime });
+        return timerId;
+    }
     return {
         setTimeout(callback, ms) {
-            const timerId = timerIdCounter++;
-            timers.set(timerId, {
-                callback,
-                interval: ms,
-                recurrent: false,
-                accumulatedTime: 0
-            });
-            return timerId;
+            return addTimer(callback, ms, false);
         },
         clearTimeout(timerId) {
             timers.delete(timerId);
         },
         setInterval(callback, ms) {
-            const timerId = timerIdCounter++;
-            timers.set(timerId, {
-                callback,
-                interval: ms,
-                recurrent: true,
-                accumulatedTime: 0
-            });
-            return timerId;
+            return addTimer(callback, ms, true);
         },
         clearInterval(timerId) {
             timers.delete(timerId);

package/dist-cjs/runtime/helpers/tree.d.ts

@@ -2,6 +2,12 @@ import { Entity } from '../../engine/entity';
 import { ComponentDefinition, IEngine } from '../../engine';
 import { Vector3Type } from '../../schemas/custom/Vector3';
 import { QuaternionType } from '../../schemas/custom/Quaternion';
+/**
+ * @public
+ * Rotate a vector by a quaternion
+ * Uses the formula: v' = q * v * q^(-1), optimized version
+ */
+export declare function rotateVectorByQuaternion(v: Vector3Type, q: QuaternionType): Vector3Type;
 /**
  * Get an iterator of entities that follow a tree structure for a component
  * @public

package/dist-cjs/runtime/helpers/tree.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorldRotation = exports.getWorldPosition = exports.getEntitiesWithParent = exports.removeEntityWithChildren = exports.getComponentEntityTree = void 0;
+exports.getWorldRotation = exports.getWorldPosition = exports.getEntitiesWithParent = exports.removeEntityWithChildren = exports.getComponentEntityTree = exports.rotateVectorByQuaternion = void 0;
 const components = __importStar(require("../../components"));
 /**
  * @internal
@@ -61,7 +61,7 @@ function multiplyQuaternions(q1, q2) {
     };
 }
 /**
- * @internal
+ * @public
  * Rotate a vector by a quaternion
  * Uses the formula: v' = q * v * q^(-1), optimized version
  */
@@ -80,6 +80,7 @@ function rotateVectorByQuaternion(v, q) {
         z: iz * qw + iw * -qz + ix * -qy - iy * -qx
     };
 }
+exports.rotateVectorByQuaternion = rotateVectorByQuaternion;
 /** @internal Identity transform values */
 const IDENTITY_POSITION = { x: 0, y: 0, z: 0 };
 const IDENTITY_ROTATION = { x: 0, y: 0, z: 0, w: 1 };

package/dist-cjs/runtime/helpers/vectors.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+/**
+ * Lightweight Vector3 math utilities for internal use.
+ * Mirrors the subset of @dcl/ecs-math Vector3 API used by the physics helpers.
+ *
+ * TEMPORARY WORKAROUND: @dcl/ecs-math ships ESM-only, which breaks the dist-cjs build.
+ * The proper fix is to add a CJS build to @dcl/ecs-math upstream, then replace this
+ * file with `import { Vector3 } from '@dcl/ecs-math'`.
+ *
+ * @internal
+ */
+exports.Vector3 = {
+    add(a, b) {
+        return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+    },
+    subtract(a, b) {
+        return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+    },
+    scale(v, s) {
+        return { x: v.x * s, y: v.y * s, z: v.z * s };
+    },
+    length(v) {
+        return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+    },
+    normalize(v) {
+        const len = exports.Vector3.length(v);
+        if (len === 0)
+            return { x: 0, y: 0, z: 0 };
+        return { x: v.x / len, y: v.y / len, z: v.z / len };
+    },
+    equals(a, b) {
+        return a.x === b.x && a.y === b.y && a.z === b.z;
+    },
+    equalsToFloats(v, x, y, z) {
+        return v.x === x && v.y === y && v.z === z;
+    }
+};

package/dist-cjs/runtime/initialization/index.d.ts

@@ -12,6 +12,7 @@ import { AssetLoadLoadingStateSystem } from '../../systems/assetLoad';
 import { TweenSystem } from '../../systems/tween';
 import { TriggerAreaEventsSystem } from '../../systems/triggerArea';
 import { createTimers, Timers } from '../helpers/timers';
+import { PhysicsSystem } from '../../systems/physics';
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -77,6 +78,12 @@ export { TriggerAreaEventsSystem };
  */
 export declare const timers: Timers;
 export { Timers, createTimers };
+/**
+ * @public
+ * Physics helpers for applying impulses and forces to the player.
+ */
+export declare const Physics: PhysicsSystem;
+export { PhysicsSystem };
 /**
  * @public
  * Runs an async function

package/dist-cjs/runtime/initialization/index.js

@@ -4,7 +4,7 @@
  * init and it'll be changing.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeTask = exports.createTimers = exports.timers = exports.triggerAreaEventsSystem = exports.tweenSystem = exports.assetLoadLoadingStateSystem = exports.videoEventsSystem = exports.raycastSystem = exports.pointerEventsSystem = exports.inputSystem = exports.engine = void 0;
+exports.executeTask = exports.Physics = exports.createTimers = exports.timers = exports.triggerAreaEventsSystem = exports.tweenSystem = exports.assetLoadLoadingStateSystem = exports.videoEventsSystem = exports.raycastSystem = exports.pointerEventsSystem = exports.inputSystem = exports.engine = void 0;
 const engine_1 = require("../../engine");
 const async_task_1 = require("../../systems/async-task");
 const events_1 = require("../../systems/events");
@@ -18,6 +18,7 @@ const triggerArea_1 = require("../../systems/triggerArea");
 const timers_1 = require("../helpers/timers");
 Object.defineProperty(exports, "createTimers", { enumerable: true, get: function () { return timers_1.createTimers; } });
 const globals_1 = require("../globals");
+const physics_1 = require("../../systems/physics");
 /**
  * @public
  * The engine is the part of the scene that sits in the middle and manages all of the other parts.
@@ -80,6 +81,11 @@ exports.timers = (0, timers_1.createTimers)(exports.engine);
 (0, globals_1.setGlobalPolyfill)('clearTimeout', exports.timers.clearTimeout);
 (0, globals_1.setGlobalPolyfill)('setInterval', exports.timers.setInterval);
 (0, globals_1.setGlobalPolyfill)('clearInterval', exports.timers.clearInterval);
+/**
+ * @public
+ * Physics helpers for applying impulses and forces to the player.
+ */
+exports.Physics = (0, physics_1.createPhysicsSystem)(exports.engine);
 /**
  * Adds pointer event collider system only in DEV env
  */

package/dist-cjs/systems/crdt/index.js

@@ -244,6 +244,12 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             const buffer = new ByteBuffer_1.ReadWriteByteBuffer();
             // Then we send all the new crdtMessages that the transport needs to process
             for (const message of crdtMessages) {
+                // Avoid echo messages
+                if (message.transportId === transportIndex)
+                    continue;
+                // Redundant message for the transport
+                if (!transport.filter(message))
+                    continue;
                 // Check if adding this message would exceed the size limit
                 const currentBufferSize = transportBuffer.toBinary().byteLength;
                 const messageSize = message.messageBuffer.byteLength;
@@ -260,12 +266,6 @@ function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                         continue;
                     }
                 }
-                // Avoid echo messages
-                if (message.transportId === transportIndex)
-                    continue;
-                // Redundant message for the transport
-                if (!transport.filter(message))
-                    continue;
                 const { entityId } = findNetworkId(message);
                 const transformNeedsFix = 'componentId' in message &&
                     message.componentId === Transform.componentId &&

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

@@ -17,12 +17,7 @@ export type EventSystemOptions = {
     showFeedback?: boolean;
     showHighlight?: boolean;
     maxPlayerDistance?: number;
-};
-/**
- * @public
- */
-export type EventSystemOptionsCallback = EventSystemOptions & {
-    cb: EventSystemCallback;
+    priority?: number;
 };
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
@@ -55,35 +50,33 @@ export interface PointerEventsSystem {
     removeOnPointerHoverLeave(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onPointerDrag event
+     * Remove the callback for onProximityDown event
      * @param entity - Entity where the callback was attached
      */
-    removeOnPointerDrag(entity: Entity): void;
+    removeOnProximityDown(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onPointerDragLocked event
+     * Remove the callback for onProximityUp event
      * @param entity - Entity where the callback was attached
      */
-    removeOnPointerDragLocked(entity: Entity): void;
+    removeOnProximityUp(entity: Entity): void;
     /**
      * @public
-     * Remove the callback for onPointerDragEnd event
+     * Remove the callback for onProximityEnter event
      * @param entity - Entity where the callback was attached
      */
-    removeOnPointerDragEnd(entity: Entity): void;
+    removeOnProximityEnter(entity: Entity): void;
     /**
      * @public
-     * Execute callbacks when the user presses one of the InputButtons pointing at the entity
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     * Remove the callback for onProximityLeave event
+     * @param entity - Entity where the callback was attached
      */
-    onPointerDown(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
+    removeOnProximityLeave(entity: Entity): void;
     /**
      * @public
      * Execute callback when the user press the InputButton pointing at the entity
      * @param pointerData - Entity to attach the callback, Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
      */
     onPointerDown(pointerData: {
         entity: Entity;
@@ -96,15 +89,6 @@ export interface PointerEventsSystem {
      * @param opts - Opts to trigger Feedback and Button
      */
     onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
-    /**
-     * @public
-     * Execute callbacks when the user releases one of the InputButtons pointing at the entity
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerUp(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
     /**
      * @public
      * Execute callback when the user releases the InputButton pointing at the entity
@@ -144,59 +128,41 @@ export interface PointerEventsSystem {
     }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callbacks when the user drags the pointer from inside the entity
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerDrag(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
-    /**
-     * @public
-     * Execute callback when the user clicks and drags the pointer from inside the entity
+     * Execute callback when the user presses the proximity button on the entity
      * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
      * @param cb - Function to execute when click fires
      */
-    onPointerDrag(pointerData: {
+    onProximityDown(pointerData: {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callbacks when the user drags the pointer from inside the entity, locking the cursor in place.
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
-     */
-    onPointerDragLocked(pointerData: {
-        entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
-    /**
-     * @public
-     * Execute callback when the user clicks and drags the pointer from inside the entity,
-     * locking the cursor in place
+     * Execute callback when the user releases the proximity button on the entity
      * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
+     * @param cb - Function to execute when event fires
      */
-    onPointerDragLocked(pointerData: {
+    onProximityUp(pointerData: {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callbacks when the user releases a button after a drag
-     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     * Execute callback when the entity enters the proximity zone of the user
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when event fires
      */
-    onPointerDragEnd(pointerData: {
+    onProximityEnter(pointerData: {
         entity: Entity;
-        optsList: EventSystemOptionsCallback[];
-    }): void;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
     /**
      * @public
-     * Execute callback when the user releases the button after a drag
+     * Execute callback when the entity leaves the proximity zone of the user
      * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
+     * @param cb - Function to execute when event fires
      */
-    onPointerDragEnd(pointerData: {
+    onProximityLeave(pointerData: {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;