@dcl/ecs 7.24.5-28985208893.commit-8caf648 → 7.24.5-29245621744.commit-336df45

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,7 +13,6 @@ 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
@@ -25,7 +24,6 @@ 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);
@@ -37,8 +35,6 @@ 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,5 +1,6 @@
 /**
- * Internal utilities for standardized globalThis access.
+ * Utilities for standardized globalThis access.
+ * @public
  */
 /**
  * Type-safe globalThis property access.

package/dist/runtime/globals.js

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

package/dist/runtime/helpers/coordinates.js

@@ -1,7 +1,3 @@
-/** 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
  */
@@ -9,8 +5,8 @@ export function areConnected(parcels) {
     if (parcels.length === 0) {
         return false;
     }
-    const visited = visitConnectedParcels(parcels[0], parcels);
-    return visited.size === parcels.length;
+    const visited = visitParcel(parcels[0], parcels);
+    return visited.length === parcels.length;
 }
 /**
  * Returns true if the given coords are equal
@@ -18,38 +14,19 @@ export function areConnected(parcels) {
 export function isEqual(p1, p2) {
     return p1.x === p2.x && p1.y === p2.y;
 }
-/**
- * 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);
-            }
-        }
+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));
     }
-    return visitedSet;
+    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));
 }
 function getNeighbours(x, y, parcels) {
-    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)));
+    return parcels.filter(getIsNeighbourMatcher(x, y));
 }

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

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

package/dist/runtime/helpers/index.js

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

package/dist/runtime/helpers/timers.js

@@ -20,59 +20,47 @@
 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 += elapsedMs;
+            timerData.accumulatedTime += 1000 * dt;
             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) {
-                // Collapse any missed periods into a single callback, keep the remainder.
-                timerData.accumulatedTime = residualMs;
+                // For intervals, subtract full interval periods to handle accumulated time
+                const fullIntervals = Math.floor(timerData.accumulatedTime / timerData.interval);
+                timerData.accumulatedTime -= fullIntervals * timerData.interval;
             }
             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) {
-            return addTimer(callback, ms, false);
+            const timerId = timerIdCounter++;
+            timers.set(timerId, {
+                callback,
+                interval: ms,
+                recurrent: false,
+                accumulatedTime: 0
+            });
+            return timerId;
         },
         clearTimeout(timerId) {
             timers.delete(timerId);
         },
         setInterval(callback, ms) {
-            return addTimer(callback, ms, true);
+            const timerId = timerIdCounter++;
+            timers.set(timerId, {
+                callback,
+                interval: ms,
+                recurrent: true,
+                accumulatedTime: 0
+            });
+            return timerId;
         },
         clearInterval(timerId) {
             timers.delete(timerId);

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

@@ -2,12 +2,6 @@ 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) {
     };
 }
 /**
- * @public
+ * @internal
  * Rotate a vector by a quaternion
  * Uses the formula: v' = q * v * q^(-1), optimized version
  */
-export function rotateVectorByQuaternion(v, q) {
+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/initialization/index.d.ts

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