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

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export * from './engine';
 export * from './schemas';
+export * from './runtime/globals';
 export * from './runtime/initialization';
 export * from './runtime/types';
 export * from './runtime/helpers';
-export * from './runtime/globals';
 export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
 export * from './systems/events';
 export * from './systems/raycast';
@@ -12,14 +12,16 @@ export * from './systems/assetLoad';
 export * from './systems/async-task';
 export * from './systems/tween';
 export * from './systems/triggerArea';
+export * from './systems/physics';
 export * from './engine/entity';
 export * from './components/types';
-import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended, AudioSourceComponentDefinitionExtended, AudioStreamComponentDefinitionExtended, ISyncComponents, TweenComponentDefinitionExtended, INetowrkEntity, INetowrkParent, VirtualCameraComponentDefinitionExtended, InputModifierComponentDefinitionExtended, LightSourceComponentDefinitionExtended, TriggerAreaComponentDefinitionExtended } from './components/types';
+import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended, AudioSourceComponentDefinitionExtended, AudioAnalysisComponentDefinitionExtended, AudioStreamComponentDefinitionExtended, ISyncComponents, TweenComponentDefinitionExtended, INetowrkEntity, INetowrkParent, VirtualCameraComponentDefinitionExtended, InputModifierComponentDefinitionExtended, LightSourceComponentDefinitionExtended, TriggerAreaComponentDefinitionExtended, ParticleSystemComponentDefinitionExtended } from './components/types';
 import { NameComponent } from './components/manual/Name';
 import { TagsComponentDefinitionExtended } from './components/manual/Tags';
 export declare const Transform: TransformComponentExtended;
 export declare const Animator: AnimatorComponentDefinitionExtended;
 export declare const AudioSource: AudioSourceComponentDefinitionExtended;
+export declare const AudioAnalysis: AudioAnalysisComponentDefinitionExtended;
 export declare const AudioStream: AudioStreamComponentDefinitionExtended;
 export declare const Material: MaterialComponentDefinitionExtended;
 export declare const MeshRenderer: MeshRendererComponentDefinitionExtended;
@@ -31,6 +33,7 @@ export declare const VirtualCamera: VirtualCameraComponentDefinitionExtended;
 export declare const InputModifier: InputModifierComponentDefinitionExtended;
 export declare const LightSource: LightSourceComponentDefinitionExtended;
 export declare const TriggerArea: TriggerAreaComponentDefinitionExtended;
+export declare const ParticleSystem: ParticleSystemComponentDefinitionExtended;
 /**
  * @alpha
  * This is going to be used for sync components through a server.

package/dist/index.js

@@ -1,10 +1,10 @@
 // The order of the following imports matters. Please do not auto-sort
 export * from './engine';
 export * from './schemas';
+export * from './runtime/globals';
 export * from './runtime/initialization';
 export * from './runtime/types';
 export * from './runtime/helpers';
-export * from './runtime/globals';
 export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
 export * from './systems/events';
 export * from './systems/raycast';
@@ -13,6 +13,7 @@ export * from './systems/assetLoad';
 export * from './systems/async-task';
 export * from './systems/tween';
 export * from './systems/triggerArea';
+export * from './systems/physics';
 export * from './engine/entity';
 export * from './components/types';
 // @internal
@@ -24,6 +25,7 @@ import { engine } from './runtime/initialization';
 export const Transform = /* @__PURE__*/ components.Transform(engine);
 export const Animator = /* @__PURE__*/ components.Animator(engine);
 export const AudioSource = /* @__PURE__*/ components.AudioSource(engine);
+export const AudioAnalysis = /* @__PURE__*/ components.AudioAnalysis(engine);
 export const AudioStream = /* @__PURE__*/ components.AudioStream(engine);
 export const Material = /* @__PURE__*/ components.Material(engine);
 export const MeshRenderer = /* @__PURE__*/ components.MeshRenderer(engine);
@@ -35,6 +37,8 @@ export const VirtualCamera = /* @__PURE__*/ components.VirtualCamera(engine);
 export const InputModifier = /* @__PURE__*/ components.InputModifier(engine);
 export const LightSource = /* @__PURE__*/ components.LightSource(engine);
 export const TriggerArea = /* @__PURE__*/ components.TriggerArea(engine);
+export const ParticleSystem = 
+/* @__PURE__*/ components.ParticleSystem(engine);
 /**
  * @alpha
  * This is going to be used for sync components through a server.

package/dist/runtime/globals.d.ts

@@ -1,6 +1,5 @@
 /**
- * Utilities for standardized globalThis access.
- * @public
+ * Internal utilities for standardized globalThis access.
  */
 /**
  * Type-safe globalThis property access.

package/dist/runtime/globals.js

@@ -1,6 +1,5 @@
 /**
- * Utilities for standardized globalThis access.
- * @public
+ * Internal utilities for standardized globalThis access.
  */
 /**
  * Type-safe globalThis property access.

package/dist/runtime/helpers/coordinates.js

@@ -1,3 +1,7 @@
+/** Returns a string representation of the given coordinates in the format "x,y" */
+function formatCoord(coord) {
+    return `${coord.x},${coord.y}`;
+}
 /**
  * Returns true if the given parcels array are connected
  */
@@ -5,8 +9,8 @@ export function areConnected(parcels) {
     if (parcels.length === 0) {
         return false;
     }
-    const visited = visitParcel(parcels[0], parcels);
-    return visited.length === parcels.length;
+    const visited = visitConnectedParcels(parcels[0], parcels);
+    return visited.size === parcels.length;
 }
 /**
  * Returns true if the given coords are equal
@@ -14,19 +18,38 @@ export function areConnected(parcels) {
 export function isEqual(p1, p2) {
     return p1.x === p2.x && p1.y === p2.y;
 }
-function visitParcel(parcel, allParcels, visited = []) {
-    const isVisited = visited.some((visitedParcel) => isEqual(visitedParcel, parcel));
-    if (!isVisited) {
-        visited.push(parcel);
-        const neighbours = getNeighbours(parcel.x, parcel.y, allParcels);
-        neighbours.forEach((neighbours) => visitParcel(neighbours, allParcels, visited));
+/**
+ * Returns the list of connected parcels starting from the given parcel.
+ * @param parcel - The starting parcel to visit
+ * @param allParcels - The list of all parcels to consider for connectivity
+ * @returns The list of connected parcels starting from the given parcel
+ * @remarks This function uses an iterative depth-first search (DFS) approach to avoid blowing the call stack on large connected parcel sets.
+ */
+function visitConnectedParcels(parcel, allParcels) {
+    const allParcelsSet = new Set(allParcels.map(formatCoord));
+    const visitedSet = new Set();
+    const stackToVisit = [parcel];
+    while (stackToVisit.length > 0) {
+        const currentParcel = stackToVisit.pop();
+        const key = formatCoord(currentParcel);
+        const isVisited = visitedSet.has(key);
+        if (!isVisited) {
+            visitedSet.add(key);
+            const neighbours = getNeighbours(currentParcel.x, currentParcel.y, allParcelsSet);
+            for (const n of neighbours) {
+                if (!visitedSet.has(formatCoord(n)))
+                    stackToVisit.push(n);
+            }
+        }
     }
-    return visited;
-}
-function getIsNeighbourMatcher(x, y) {
-    return (coords) => (coords.x === x && (coords.y + 1 === y || coords.y - 1 === y)) ||
-        (coords.y === y && (coords.x + 1 === x || coords.x - 1 === x));
+    return visitedSet;
 }
 function getNeighbours(x, y, parcels) {
-    return parcels.filter(getIsNeighbourMatcher(x, y));
+    const neighbourCandidates = [
+        { x: x + 1, y },
+        { x: x - 1, y },
+        { x, y: y + 1 },
+        { x, y: y - 1 }
+    ];
+    return neighbourCandidates.filter((c) => parcels.has(formatCoord(c)));
 }

package/dist/runtime/helpers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './coordinates';
 export * from './tree';
+export * from './vectors';
 export { createTimers, Timers, TimerId, TimerCallback } from './timers';

package/dist/runtime/helpers/index.js

@@ -1,3 +1,4 @@
 export * from './coordinates';
 export * from './tree';
+export * from './vectors';
 export { createTimers } from './timers';

package/dist/runtime/helpers/timers.js

@@ -20,47 +20,59 @@
 export 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/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/runtime/helpers/tree.js

@@ -35,11 +35,11 @@ function multiplyQuaternions(q1, q2) {
     };
 }
 /**
- * @internal
+ * @public
  * Rotate a vector by a quaternion
  * Uses the formula: v' = q * v * q^(-1), optimized version
  */
-function rotateVectorByQuaternion(v, q) {
+export function rotateVectorByQuaternion(v, q) {
     // Extract quaternion components
     const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
     // Calculate cross product terms (q.xyz × v) * 2

package/dist/runtime/helpers/vectors.js

@@ -0,0 +1,36 @@
+/**
+ * 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
+ */
+export const 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 = 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/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/runtime/initialization/index.js

@@ -14,6 +14,7 @@ import { pointerEventColliderChecker } from '../../systems/pointer-event-collide
 import { createTriggerAreaEventsSystem } from '../../systems/triggerArea';
 import { createTimers } from '../helpers/timers';
 import { setGlobalPolyfill } from '../globals';
+import { createPhysicsSystem } 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,11 @@ setGlobalPolyfill('setTimeout', timers.setTimeout);
 setGlobalPolyfill('clearTimeout', timers.clearTimeout);
 setGlobalPolyfill('setInterval', timers.setInterval);
 setGlobalPolyfill('clearInterval', timers.clearInterval);
+/**
+ * @public
+ * Physics helpers for applying impulses and forces to the player.
+ */
+export const Physics = /* @__PURE__ */ createPhysicsSystem(engine);
 /**
  * Adds pointer event collider system only in DEV env
  */

package/dist/systems/crdt/index.js

@@ -218,6 +218,12 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             const buffer = new 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;
@@ -234,12 +240,6 @@ export 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/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;