dcl-npc-toolkit 1.5.2-20250415203310.commit-be60b9e → 1.5.2-20251229114702.commit-02ef366

package/dist/utils/math.d.ts

@@ -0,0 +1,28 @@
+import { Entity } from '@dcl/sdk/ecs';
+import { Vector3, Quaternion } from '@dcl/sdk/math';
+export declare function remap(value: number, min1: number, max1: number, min2: number, max2: number): number;
+export declare function getWorldPosition(entity: Entity): Vector3;
+export declare function getWorldRotation(entity: Entity): Quaternion;
+export declare enum InterpolationType {
+    LINEAR = "linear",
+    EASEINQUAD = "easeinquad",
+    EASEOUTQUAD = "easeoutquad",
+    EASEQUAD = "easequad",
+    EASEINSINE = "easeinsine",
+    EASEOUTSINE = "easeoutsine",
+    EASESINE = "easeinoutsine",
+    EASEINEXPO = "easeinexpo",
+    EASEOUTEXPO = "easeoutexpo",
+    EASEEXPO = "easeinoutexpo",
+    EASEINELASTIC = "easeinelastic",
+    EASEOUTELASTIC = "easeoutelastic",
+    EASEELASTIC = "easeinoutelastic",
+    EASEINBOUNCE = "easeinbounce",
+    EASEOUTEBOUNCE = "easeoutbounce",
+    EASEBOUNCE = "easeinoutbounce"
+}
+export declare function interpolate(type: InterpolationType, t: number): number;
+export declare function createCatmullRomSpline(points: Vector3[], nbPoints: number, closed?: boolean): Vector3[];
+export declare function areAABBIntersecting(aMin: Vector3, aMax: Vector3, bMin: Vector3, bMax: Vector3): boolean;
+export declare function areSpheresIntersecting(aPos: Vector3, aRadius: number, bPos: Vector3, bRadius: number): boolean;
+export declare function areAABBSphereIntersecting(boxMin: Vector3, boxMax: Vector3, spherePos: Vector3, sphereRadius: number): boolean;

package/dist/utils/math.js

@@ -0,0 +1,239 @@
+import { Transform } from '@dcl/sdk/ecs';
+import { Vector3, Quaternion } from '@dcl/sdk/math';
+export function remap(value, min1, max1, min2, max2) {
+    let range1 = max1 - min1;
+    let range2 = max2 - min2;
+    return ((value - min1) / range1) * range2 + min2;
+}
+export function getWorldPosition(entity) {
+    let transform = Transform.getOrNull(entity);
+    if (!transform)
+        return Vector3.Zero();
+    let parent = transform.parent;
+    if (!parent) {
+        return transform.position;
+    }
+    else {
+        let parentRotation = Transform.get(parent).rotation;
+        return Vector3.add(getWorldPosition(parent), Vector3.rotate(transform.position, getWorldRotation(parent)));
+    }
+}
+export function getWorldRotation(entity) {
+    let transform = Transform.getOrNull(entity);
+    if (!transform)
+        return Quaternion.Identity();
+    let parent = transform.parent;
+    if (!parent) {
+        return transform.rotation;
+    }
+    else {
+        return Quaternion.multiply(transform.rotation, getWorldRotation(parent));
+    }
+}
+export var InterpolationType;
+(function (InterpolationType) {
+    InterpolationType["LINEAR"] = "linear";
+    InterpolationType["EASEINQUAD"] = "easeinquad";
+    InterpolationType["EASEOUTQUAD"] = "easeoutquad";
+    InterpolationType["EASEQUAD"] = "easequad";
+    InterpolationType["EASEINSINE"] = "easeinsine";
+    InterpolationType["EASEOUTSINE"] = "easeoutsine";
+    InterpolationType["EASESINE"] = "easeinoutsine";
+    InterpolationType["EASEINEXPO"] = "easeinexpo";
+    InterpolationType["EASEOUTEXPO"] = "easeoutexpo";
+    InterpolationType["EASEEXPO"] = "easeinoutexpo";
+    InterpolationType["EASEINELASTIC"] = "easeinelastic";
+    InterpolationType["EASEOUTELASTIC"] = "easeoutelastic";
+    InterpolationType["EASEELASTIC"] = "easeinoutelastic";
+    InterpolationType["EASEINBOUNCE"] = "easeinbounce";
+    InterpolationType["EASEOUTEBOUNCE"] = "easeoutbounce";
+    InterpolationType["EASEBOUNCE"] = "easeinoutbounce";
+})(InterpolationType || (InterpolationType = {}));
+export function interpolate(type, t) {
+    switch (type) {
+        case InterpolationType.LINEAR:
+            return InterpolateLinear(t);
+        case InterpolationType.EASEINQUAD:
+            return InterpolateEaseInQuad(t);
+        case InterpolationType.EASEOUTQUAD:
+            return InterpolateEaseOutQuad(t);
+        case InterpolationType.EASEQUAD:
+            return InterpolateEaseQuad(t);
+        case InterpolationType.EASEINSINE:
+            return InterpolateEaseInSine(t);
+        case InterpolationType.EASEOUTSINE:
+            return InterpolateEaseOutSine(t);
+        case InterpolationType.EASESINE:
+            return InterpolateEaseInOutSine(t);
+        case InterpolationType.EASEINEXPO:
+            return InterpolateEaseInExpo(t);
+        case InterpolationType.EASEOUTEXPO:
+            return InterpolateEaseOutExpo(t);
+        case InterpolationType.EASEEXPO:
+            return InterpolateEaseInOutExpo(t);
+        case InterpolationType.EASEINELASTIC:
+            return InterpolateEaseInElastic(t);
+        case InterpolationType.EASEOUTELASTIC:
+            return InterpolateEaseOutElastic(t);
+        case InterpolationType.EASEELASTIC:
+            return InterpolateEaseInOutElastic(t);
+        case InterpolationType.EASEINBOUNCE:
+            return InterpolateEaseInBounce(t);
+        case InterpolationType.EASEOUTEBOUNCE:
+            return InterpolateEaseOutBounce(t);
+        case InterpolationType.EASEBOUNCE:
+            return InterpolateEaseInOutBounce(t);
+        default:
+            return InterpolateLinear(t);
+    }
+}
+function InterpolateLinear(t) {
+    return t;
+}
+function InterpolateEaseInQuad(t) {
+    return t * t;
+}
+function InterpolateEaseOutQuad(t) {
+    return t * (2 - t);
+}
+function InterpolateEaseQuad(t) {
+    return (t * t) / (2.0 * (t * t - t) + 1.0);
+}
+function InterpolateEaseInSine(t) {
+    return 1 - Math.cos((t * Math.PI) / 2);
+}
+function InterpolateEaseOutSine(t) {
+    return Math.sin((t * Math.PI) / 2);
+}
+function InterpolateEaseInOutSine(t) {
+    return -(Math.cos(Math.PI * t) - 1) / 2;
+}
+function InterpolateEaseInExpo(t) {
+    return t === 0 ? 0 : Math.pow(2, 10 * t - 10);
+}
+function InterpolateEaseOutExpo(t) {
+    return t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+}
+function InterpolateEaseInOutExpo(t) {
+    return t === 0
+        ? 0
+        : t === 1
+            ? 1
+            : t < 0.5
+                ? Math.pow(2, 20 * t - 10) / 2
+                : (2 - Math.pow(2, -20 * t + 10)) / 2;
+}
+function InterpolateEaseInElastic(t) {
+    const c4 = (2 * Math.PI) / 3;
+    return t === 0
+        ? 0
+        : t === 1
+            ? 1
+            : -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * c4);
+}
+function InterpolateEaseOutElastic(t) {
+    const c5 = (2 * Math.PI) / 3;
+    return t === 0
+        ? 0
+        : t === 1
+            ? 1
+            : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c5) + 1;
+}
+function InterpolateEaseInOutElastic(t) {
+    const c6 = (2 * Math.PI) / 4.5;
+    return t === 0
+        ? 0
+        : t === 1
+            ? 1
+            : t < 0.5
+                ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c6)) / 2
+                : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c6)) / 2 + 1;
+}
+function InterpolateEaseInBounce(t) {
+    return 1 - bounce(1 - t);
+}
+function InterpolateEaseOutBounce(t) {
+    return bounce(t);
+}
+function InterpolateEaseInOutBounce(t) {
+    return t < 0.5 ? (1 - bounce(1 - 2 * t)) / 2 : (1 + bounce(2 * t - 1)) / 2;
+}
+function bounce(x) {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (x < 1 / d1) {
+        return n1 * x * x;
+    }
+    else if (x < 2 / d1) {
+        return n1 * (x -= 1.5 / d1) * x + 0.75;
+    }
+    else if (x < 2.5 / d1) {
+        return n1 * (x -= 2.25 / d1) * x + 0.9375;
+    }
+    else {
+        return n1 * (x -= 2.625 / d1) * x + 0.984375;
+    }
+}
+export function createCatmullRomSpline(points, nbPoints, closed) {
+    const catmullRom = new Array();
+    const step = 1.0 / nbPoints;
+    let amount = 0.0;
+    if (closed) {
+        const pointsCount = points.length;
+        for (let i = 0; i < pointsCount; i++) {
+            amount = 0;
+            for (let c = 0; c < nbPoints; c++) {
+                catmullRom.push(Vector3.catmullRom(points[i % pointsCount], points[(i + 1) % pointsCount], points[(i + 2) % pointsCount], points[(i + 3) % pointsCount], amount));
+                amount += step;
+            }
+        }
+        catmullRom.push(catmullRom[0]);
+    }
+    else {
+        const totalPoints = new Array();
+        totalPoints.push(Vector3.clone(points[0]));
+        Array.prototype.push.apply(totalPoints, points);
+        totalPoints.push(Vector3.clone(points[points.length - 1]));
+        let i = 0;
+        for (; i < totalPoints.length - 3; i++) {
+            amount = 0;
+            for (let c = 0; c < nbPoints; c++) {
+                catmullRom.push(Vector3.catmullRom(totalPoints[i], totalPoints[i + 1], totalPoints[i + 2], totalPoints[i + 3], amount));
+                amount += step;
+            }
+        }
+        i--;
+        catmullRom.push(Vector3.catmullRom(totalPoints[i], totalPoints[i + 1], totalPoints[i + 2], totalPoints[i + 3], amount));
+    }
+    return catmullRom;
+}
+export function areAABBIntersecting(aMin, aMax, bMin, bMax) {
+    return (aMin.x <= bMax.x &&
+        aMax.x >= bMin.x &&
+        aMin.y <= bMax.y &&
+        aMax.y >= bMin.y &&
+        aMin.z <= bMax.z &&
+        aMax.z >= bMin.z);
+}
+export function areSpheresIntersecting(aPos, aRadius, bPos, bRadius) {
+    const sqDist = Vector3.distanceSquared(aPos, bPos);
+    const radiusSum = aRadius + bRadius;
+    return sqDist < radiusSum * radiusSum;
+}
+export function areAABBSphereIntersecting(boxMin, boxMax, spherePos, sphereRadius) {
+    let dmin = 0;
+    if (spherePos.x < boxMin.x)
+        dmin += (boxMin.x - spherePos.x) * (boxMin.x - spherePos.x);
+    if (spherePos.x > boxMax.x)
+        dmin += (spherePos.x - boxMax.x) * (spherePos.x - boxMax.x);
+    if (spherePos.y < boxMin.y)
+        dmin += (boxMin.y - spherePos.y) * (boxMin.y - spherePos.y);
+    if (spherePos.y > boxMax.y)
+        dmin += (spherePos.y - boxMax.y) * (spherePos.y - boxMax.y);
+    if (spherePos.z < boxMin.z)
+        dmin += (boxMin.z - spherePos.z) * (boxMin.z - spherePos.z);
+    if (spherePos.z > boxMax.z)
+        dmin += (spherePos.z - boxMax.z) * (spherePos.z - boxMax.z);
+    return dmin < sphereRadius * sphereRadius;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"math.js","sourceRoot":"","sources":["../../src/utils/math.ts"],"names":[],"mappings":"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","sourcesContent":["import { Entity, Transform } from '@dcl/sdk/ecs'\nimport { Vector3, Quaternion } from '@dcl/sdk/math'\n\n/**\n * Remaps a value from one range of values to its equivalent, scaled in proportion to another range of values, using maximum and minimum.\n *\n * @param value - value input number\n * @param min1 - min1 Minimum value in the range of the input.\n * @param max1 - max1 Maximum value in the range of the input.\n * @param min2 - min2 Minimum value in the range of the output.\n * @param max2 - max2 Maximum value in the range of the output.\n * @returns The resulting remapped value between the new min and max\n * @public\n */\nexport function remap(\n  value: number,\n  min1: number,\n  max1: number,\n  min2: number,\n  max2: number\n) {\n  let range1 = max1 - min1\n  let range2 = max2 - min2\n  return ((value - min1) / range1) * range2 + min2\n}\n\n/**\n * Returns the position of an entity that is a child of other entities, relative to the scene instead of relative to the parent. Returns a Vector3.\n *\n * @param entity - Entity to calculate position\n * @returns The Entity's global position relative to the scene's origin\n * @public\n */\nexport function getWorldPosition(entity: Entity): Vector3 {\n  let transform = Transform.getOrNull(entity)\n\n\n  if (!transform) return Vector3.Zero()\n\n  let parent = transform.parent\n\n  if (!parent) {\n    return transform.position\n  } else {\n    let parentRotation = Transform.get(parent).rotation\n    return Vector3.add(getWorldPosition(parent), Vector3.rotate(transform.position, getWorldRotation(parent)))\n  }\n}\n\n/**\n * Returns the position of an entity that is a child of other entities, relative to the scene instead of relative to the parent. Returns a Vector3.\n *\n * @param entity - Entity to calculate position\n * @returns The Entity's global rotation in reference to the scene's origin\n * @public\n */\nexport function getWorldRotation(entity: Entity): Quaternion {\n  let transform = Transform.getOrNull(entity)\n\n  if (!transform)\n    return Quaternion.Identity()\n\n  let parent = transform.parent\n\n  if (!parent) {\n    return transform.rotation\n  } else {\n    return Quaternion.multiply(transform.rotation, getWorldRotation(parent))\n  }\n}\n\n/**\n * @public\n */\nexport enum InterpolationType {\n  LINEAR = 'linear',\n\n  EASEINQUAD = 'easeinquad',\n  EASEOUTQUAD = 'easeoutquad',\n  EASEQUAD = 'easequad',\n\n  EASEINSINE = 'easeinsine',\n  EASEOUTSINE = 'easeoutsine',\n  EASESINE = 'easeinoutsine',\n\n  EASEINEXPO = 'easeinexpo',\n  EASEOUTEXPO = 'easeoutexpo',\n  EASEEXPO = 'easeinoutexpo',\n\n  EASEINELASTIC = 'easeinelastic',\n  EASEOUTELASTIC = 'easeoutelastic',\n  EASEELASTIC = 'easeinoutelastic',\n\n  EASEINBOUNCE = 'easeinbounce',\n  EASEOUTEBOUNCE = 'easeoutbounce',\n  EASEBOUNCE = 'easeinoutbounce',\n}\n\n/**\n * @public\n */\nexport function interpolate(type: InterpolationType, t: number): number {\n  switch (type) {\n    case InterpolationType.LINEAR:\n      return InterpolateLinear(t)\n    case InterpolationType.EASEINQUAD:\n      return InterpolateEaseInQuad(t)\n    case InterpolationType.EASEOUTQUAD:\n      return InterpolateEaseOutQuad(t)\n    case InterpolationType.EASEQUAD:\n      return InterpolateEaseQuad(t)\n\t  case InterpolationType.EASEINSINE:\n\t\t  return InterpolateEaseInSine(t)\n    case InterpolationType.EASEOUTSINE:\n      return InterpolateEaseOutSine(t)\n    case InterpolationType.EASESINE:\n      return InterpolateEaseInOutSine(t)\n    case InterpolationType.EASEINEXPO:\n      return InterpolateEaseInExpo(t)\n    case InterpolationType.EASEOUTEXPO:\n      return InterpolateEaseOutExpo(t)\n    case InterpolationType.EASEEXPO:\n      return InterpolateEaseInOutExpo(t)\n    case InterpolationType.EASEINELASTIC:\n      return InterpolateEaseInElastic(t)\n    case InterpolationType.EASEOUTELASTIC:\n      return InterpolateEaseOutElastic(t)\n    case InterpolationType.EASEELASTIC:\n      return InterpolateEaseInOutElastic(t)\n    case InterpolationType.EASEINBOUNCE:\n      return InterpolateEaseInBounce(t)\n    case InterpolationType.EASEOUTEBOUNCE:\n      return InterpolateEaseOutBounce(t)\n    case InterpolationType.EASEBOUNCE:\n      return InterpolateEaseInOutBounce(t)\n    default:\n      return InterpolateLinear(t)\n  }\n}\n\nfunction InterpolateLinear(t: number): number {\n  return t\n}\n\nfunction InterpolateEaseInQuad(t: number): number {\n  return t * t\n}\n\nfunction InterpolateEaseOutQuad(t: number): number {\n  return t * (2 - t)\n}\n\nfunction InterpolateEaseQuad(t: number): number {\n  return (t * t) / (2.0 * (t * t - t) + 1.0)\n}\n\nfunction InterpolateEaseInSine(t: number): number {\n\treturn 1 - Math.cos((t * Math.PI) / 2)\n}\n\nfunction InterpolateEaseOutSine(t: number): number {\n\treturn Math.sin((t * Math.PI) / 2)\n}\n\nfunction InterpolateEaseInOutSine(t: number): number {\n\treturn -(Math.cos(Math.PI * t) - 1) / 2\n}\n\nfunction InterpolateEaseInExpo(t: number): number {\n\treturn t === 0 ? 0 : Math.pow(2, 10 * t - 10)\n}\n\nfunction InterpolateEaseOutExpo(t: number): number {\n\treturn t === 1 ? 1 : 1 - Math.pow(2, -10 * t)\n}\n\nfunction InterpolateEaseInOutExpo(t: number): number {\n\treturn t === 0\n\t\t\t? 0\n\t\t\t: t === 1\n\t\t\t? 1\n\t\t\t: t < 0.5\n\t\t\t? Math.pow(2, 20 * t - 10) / 2\n\t\t\t: (2 - Math.pow(2, -20 * t + 10)) / 2\n}\n\n\nfunction InterpolateEaseInElastic(t: number): number {\n\tconst c4 = (2 * Math.PI) / 3\n\n\treturn t === 0\n\t\t\t? 0\n\t\t\t: t === 1\n\t\t\t? 1\n\t\t\t: -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * c4)\n}\n\nfunction InterpolateEaseOutElastic(t: number): number {\n\tconst c5 = (2 * Math.PI) / 3\n\n\treturn t === 0\n\t\t\t? 0\n\t\t\t: t === 1\n\t\t\t? 1\n\t\t\t: Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c5) + 1\n}\n\nfunction InterpolateEaseInOutElastic(t: number): number {\n\tconst c6 = (2 * Math.PI) / 4.5\n\n\treturn t === 0\n\t\t\t? 0\n\t\t\t: t === 1\n\t\t\t? 1\n\t\t\t: t < 0.5\n\t\t\t? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c6)) / 2\n\t\t\t: (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c6)) / 2 + 1\n}\n\nfunction InterpolateEaseInBounce(t: number): number {\n\treturn 1 - bounce(1 - t)\n}\n\nfunction InterpolateEaseOutBounce(t: number): number {\n\treturn bounce(t)\n}\n\nfunction InterpolateEaseInOutBounce(t: number): number {\n\treturn t < 0.5 ? (1 - bounce(1 - 2 * t)) / 2 : (1 + bounce(2 * t - 1)) / 2\n}\n\nfunction bounce(x: number) {\n\tconst n1 = 7.5625\n\tconst d1 = 2.75\n\n\tif (x < 1 / d1) {\n\t\treturn n1 * x * x\n\t} else if (x < 2 / d1) {\n\t\treturn n1 * (x -= 1.5 / d1) * x + 0.75\n\t} else if (x < 2.5 / d1) {\n\t\treturn n1 * (x -= 2.25 / d1) * x + 0.9375\n\t} else {\n\t\treturn n1 * (x -= 2.625 / d1) * x + 0.984375\n\t}\n}\n\nexport function createCatmullRomSpline(points: Vector3[], nbPoints: number, closed?: boolean): Vector3[] {\n\tconst catmullRom = new Array<Vector3>();\n\tconst step = 1.0 / nbPoints;\n\tlet amount = 0.0;\n\tif (closed) {\n\t\tconst pointsCount = points.length;\n\t\tfor (let i = 0; i < pointsCount; i++) {\n\t\t\tamount = 0;\n\t\t\tfor (let c = 0; c < nbPoints; c++) {\n\t\t\t\tcatmullRom.push(\n\t\t\t\t\tVector3.catmullRom(points[i % pointsCount], points[(i + 1) % pointsCount], points[(i + 2) % pointsCount], points[(i + 3) % pointsCount], amount)\n\t\t\t\t);\n\t\t\t\tamount += step;\n\t\t\t}\n\t\t}\n\t\tcatmullRom.push(catmullRom[0]);\n\t} else {\n\t\tconst totalPoints = new Array<Vector3>();\n\t\ttotalPoints.push(Vector3.clone(points[0]));\n\t\tArray.prototype.push.apply(totalPoints, points);\n\t\ttotalPoints.push(Vector3.clone(points[points.length - 1]));\n\t\tlet i = 0;\n\t\tfor (; i < totalPoints.length - 3; i++) {\n\t\t\tamount = 0;\n\t\t\tfor (let c = 0; c < nbPoints; c++) {\n\t\t\t\tcatmullRom.push(Vector3.catmullRom(totalPoints[i], totalPoints[i + 1], totalPoints[i + 2], totalPoints[i + 3], amount));\n\t\t\t\tamount += step;\n\t\t\t}\n\t\t}\n\t\ti--;\n\t\tcatmullRom.push(Vector3.catmullRom(totalPoints[i], totalPoints[i + 1], totalPoints[i + 2], totalPoints[i + 3], amount));\n\t}\n\treturn catmullRom;\n}\n\nexport function areAABBIntersecting(aMin: Vector3, aMax: Vector3, bMin: Vector3, bMax: Vector3): boolean {\n\treturn (\n\t\taMin.x <= bMax.x &&\n\t\taMax.x >= bMin.x &&\n\t\taMin.y <= bMax.y &&\n\t\taMax.y >= bMin.y &&\n\t\taMin.z <= bMax.z &&\n\t\taMax.z >= bMin.z\n\t)\n}\n\nexport function areSpheresIntersecting(aPos: Vector3, aRadius: number, bPos: Vector3, bRadius: number): boolean {\n  const sqDist = Vector3.distanceSquared(aPos, bPos)\n  const radiusSum = aRadius + bRadius\n  return sqDist < radiusSum * radiusSum\n}\n\nexport function areAABBSphereIntersecting(boxMin: Vector3, boxMax: Vector3, spherePos: Vector3, sphereRadius: number): boolean {\n  let dmin = 0\n\n  if (spherePos.x < boxMin.x)\n    dmin += (boxMin.x - spherePos.x) * (boxMin.x - spherePos.x)\n  if (spherePos.x > boxMax.x)\n    dmin += (spherePos.x - boxMax.x) * (spherePos.x - boxMax.x)\n  if (spherePos.y < boxMin.y)\n    dmin += (boxMin.y - spherePos.y) * (boxMin.y - spherePos.y)\n  if (spherePos.y > boxMax.y)\n    dmin += (spherePos.y - boxMax.y) * (spherePos.y - boxMax.y)\n  if (spherePos.z < boxMin.z)\n    dmin += (boxMin.z - spherePos.z) * (boxMin.z - spherePos.z)\n  if (spherePos.z > boxMax.z)\n    dmin += (spherePos.z - boxMax.z) * (spherePos.z - boxMax.z)\n\n  return dmin < sphereRadius * sphereRadius\n}\n"]}

package/dist/utils/path.d.ts

@@ -0,0 +1,18 @@
+import { Entity, IEngine } from '@dcl/sdk/ecs';
+import { Vector3 } from '@dcl/sdk/math';
+export type Paths = ReturnType<typeof createPaths>;
+export type OnFinishCallback = () => void;
+export type OnPointReachedCallback = (pointIndex: number, point: Vector3, nextPoint: Vector3) => void;
+declare function createPaths(targetEngine: IEngine): {
+    startStraightPath(entity: Entity, points: Vector3[], duration: number, faceDirection?: boolean, onFinishCallback?: OnFinishCallback, onPointReachedCallback?: OnPointReachedCallback): void;
+    startSmoothPath(entity: Entity, points: Vector3[], duration: number, segmentCount: number, faceDirection?: boolean, onFinishCallback?: OnFinishCallback, onPointReachedCallback?: OnPointReachedCallback): void;
+    stopPath(entity: Entity): void;
+    getOnFinishCallback(entity: Entity): OnFinishCallback | undefined;
+};
+export declare const paths: {
+    startStraightPath(entity: Entity, points: Vector3[], duration: number, faceDirection?: boolean, onFinishCallback?: OnFinishCallback, onPointReachedCallback?: OnPointReachedCallback): void;
+    startSmoothPath(entity: Entity, points: Vector3[], duration: number, segmentCount: number, faceDirection?: boolean, onFinishCallback?: OnFinishCallback, onPointReachedCallback?: OnPointReachedCallback): void;
+    stopPath(entity: Entity): void;
+    getOnFinishCallback(entity: Entity): OnFinishCallback | undefined;
+};
+export {};

package/dist/utils/path.js

@@ -0,0 +1,125 @@
+import { engine, EntityState, Schemas, Transform } from '@dcl/sdk/ecs';
+import { Scalar, Vector3, Quaternion } from '@dcl/sdk/math';
+import { createCatmullRomSpline } from './math';
+function createPaths(targetEngine) {
+    const FollowPath = targetEngine.defineComponent('dcl.utils.FollowPath', {
+        points: Schemas.Array(Schemas.Vector3),
+        faceDirection: Schemas.Boolean,
+        speed: Schemas.Number,
+        normalizedTime: Schemas.Number,
+        currentIndex: Schemas.Number,
+        segmentTimes: Schemas.Array(Schemas.Number),
+        curveSegmentCount: Schemas.Number
+    });
+    const finishCbs = new Map();
+    const pointReachedCbs = new Map();
+    function unregisterEntity(entity) {
+        finishCbs.delete(entity);
+        pointReachedCbs.delete(entity);
+        FollowPath.deleteFrom(entity);
+    }
+    function system(dt) {
+        const deadPaths = [];
+        const pointReachedPaths = [];
+        for (const entity of finishCbs.keys()) {
+            if (targetEngine.getEntityState(entity) == EntityState.Removed || !FollowPath.has(entity)) {
+                unregisterEntity(entity);
+                continue;
+            }
+            const transform = Transform.getMutable(entity);
+            const path = FollowPath.getMutable(entity);
+            path.normalizedTime = Scalar.clamp(path.normalizedTime + dt * path.speed, 0, 1);
+            if (path.normalizedTime >= 1)
+                deadPaths.push(entity);
+            while (path.normalizedTime >= path.segmentTimes[path.currentIndex] &&
+                path.currentIndex < path.points.length - 1) {
+                if (path.faceDirection) {
+                    const direction = Vector3.subtract(path.points[path.currentIndex + 1], path.points[path.currentIndex]);
+                    transform.rotation = Quaternion.lookRotation(direction);
+                }
+                if (path.currentIndex > 0 && path.currentIndex % path.curveSegmentCount == 0) {
+                    const pointIndex = path.currentIndex / path.curveSegmentCount;
+                    const pointCoords = path.points[path.currentIndex];
+                    const nextPointCoords = path.points[path.currentIndex + path.curveSegmentCount];
+                    pointReachedPaths.push({ entity: entity, index: pointIndex, coords: pointCoords, nextCoords: nextPointCoords });
+                }
+                path.currentIndex += 1;
+            }
+            const timeDiff = path.segmentTimes[path.currentIndex] - path.segmentTimes[path.currentIndex - 1];
+            const coef = (path.segmentTimes[path.currentIndex] - path.normalizedTime) / timeDiff;
+            transform.position = Vector3.lerp(path.points[path.currentIndex], path.points[path.currentIndex - 1], coef);
+        }
+        for (const pointReached of pointReachedPaths) {
+            const callback = pointReachedCbs.get(pointReached.entity);
+            if (callback) {
+                callback(pointReached.index, pointReached.coords, pointReached.nextCoords);
+            }
+        }
+        for (const entity of deadPaths) {
+            const callback = finishCbs.get(entity);
+            unregisterEntity(entity);
+            if (callback)
+                callback();
+        }
+    }
+    targetEngine.addSystem(system);
+    function startPath(entity, points, duration, faceDirection, curveSegmentCount, onFinishCallback, onPointReachedCallback) {
+        if (points.length < 2)
+            throw new Error('At least 2 points are required to form a path.');
+        if (duration == 0)
+            throw new Error('Path duration must not be zero');
+        if (curveSegmentCount) {
+            const loop = Vector3.equals(points[0], points[points.length - 1]);
+            if (loop) {
+                points.pop();
+                points.unshift(points.pop());
+            }
+            points = createCatmullRomSpline(points, curveSegmentCount, loop);
+        }
+        else {
+            curveSegmentCount = 1;
+        }
+        finishCbs.set(entity, onFinishCallback);
+        pointReachedCbs.set(entity, onPointReachedCallback);
+        let totalLength = 0;
+        const segmentLengths = [];
+        for (let i = 0; i < points.length - 1; i++) {
+            let sqDist = Vector3.distance(points[i], points[i + 1]);
+            totalLength += sqDist;
+            segmentLengths.push(sqDist);
+        }
+        const segmentTimes = [0];
+        for (let i = 0; i < segmentLengths.length; i++) {
+            segmentTimes.push(segmentLengths[i] / totalLength + segmentTimes[i]);
+        }
+        FollowPath.createOrReplace(entity, {
+            points: points,
+            segmentTimes: segmentTimes,
+            curveSegmentCount: curveSegmentCount,
+            speed: 1 / duration,
+            normalizedTime: 0,
+            currentIndex: 0,
+            faceDirection: faceDirection
+        });
+    }
+    return {
+        startStraightPath(entity, points, duration, faceDirection, onFinishCallback, onPointReachedCallback) {
+            return startPath(entity, points, duration, faceDirection, 0, onFinishCallback, onPointReachedCallback);
+        },
+        startSmoothPath(entity, points, duration, segmentCount, faceDirection, onFinishCallback, onPointReachedCallback) {
+            if (segmentCount < 2 || !Number.isInteger(segmentCount))
+                throw new Error(`segmentCount must be an integer that is greater than 2, got: ${segmentCount}`);
+            return startPath(entity, points, duration, faceDirection, segmentCount, onFinishCallback, onPointReachedCallback);
+        },
+        stopPath(entity) {
+            unregisterEntity(entity);
+        },
+        getOnFinishCallback(entity) {
+            if (!finishCbs.has(entity))
+                throw new Error(`Entity ${entity} is not registered in triggers system`);
+            return finishCbs.get(entity);
+        }
+    };
+}
+export const paths = createPaths(engine);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"path.js","sourceRoot":"","sources":["../../src/utils/path.ts"],"names":[],"mappings":"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","sourcesContent":["import { engine, Entity, EntityState, IEngine, Schemas, Transform } from '@dcl/sdk/ecs'\nimport { Scalar, Vector3, Quaternion } from '@dcl/sdk/math'\nimport { createCatmullRomSpline } from './math'\n\n\nexport type Paths = ReturnType<typeof createPaths>\n\nexport type OnFinishCallback = () => void\nexport type OnPointReachedCallback = (pointIndex: number, point: Vector3, nextPoint: Vector3) => void\n\nfunction createPaths(targetEngine: IEngine) {\n  const FollowPath = targetEngine.defineComponent('dcl.utils.FollowPath', {\n    points: Schemas.Array(Schemas.Vector3),\n    faceDirection: Schemas.Boolean,\n    speed: Schemas.Number,\n    normalizedTime: Schemas.Number,\n    currentIndex: Schemas.Number,\n    segmentTimes: Schemas.Array(Schemas.Number),\n    curveSegmentCount: Schemas.Number\n  })\n\n  type FinishCallbackMap = Map<Entity, OnFinishCallback | undefined>\n  type OnPointReachedCallbackMap = Map<Entity, OnPointReachedCallback | undefined>\n\n  const finishCbs: FinishCallbackMap = new Map()\n  const pointReachedCbs: OnPointReachedCallbackMap = new Map()\n\n  function unregisterEntity(entity: Entity) {\n    finishCbs.delete(entity)\n    pointReachedCbs.delete(entity)\n    FollowPath.deleteFrom(entity)\n  }\n\n  function system(dt: number) {\n    const deadPaths = []\n    const pointReachedPaths = []\n\n    for (const entity of finishCbs.keys()) {\n      if (targetEngine.getEntityState(entity) == EntityState.Removed || !FollowPath.has(entity)) {\n        unregisterEntity(entity)\n        continue\n      }\n\n      const transform = Transform.getMutable(entity)\n      const path = FollowPath.getMutable(entity)\n      path.normalizedTime = Scalar.clamp(path.normalizedTime + dt * path.speed, 0, 1)\n      if (path.normalizedTime >= 1)\n        deadPaths.push(entity)\n\n      while (\n        path.normalizedTime >= path.segmentTimes[path.currentIndex] &&\n        path.currentIndex < path.points.length - 1\n      ) {\n        if (path.faceDirection) {\n          const direction = Vector3.subtract(path.points[path.currentIndex + 1], path.points[path.currentIndex])\n          transform.rotation = Quaternion.lookRotation(direction)\n        }\n        if (path.currentIndex > 0 && path.currentIndex % path.curveSegmentCount == 0) {\n          const pointIndex = path.currentIndex / path.curveSegmentCount\n          const pointCoords = path.points[path.currentIndex]\n          const nextPointCoords = path.points[path.currentIndex + path.curveSegmentCount]\n          pointReachedPaths.push({entity: entity, index: pointIndex, coords: pointCoords, nextCoords: nextPointCoords})\n        }\n        path.currentIndex += 1\n      }\n\n      const timeDiff = path.segmentTimes[path.currentIndex] - path.segmentTimes[path.currentIndex - 1]\n      const coef = (path.segmentTimes[path.currentIndex] - path.normalizedTime) / timeDiff\n      transform.position = Vector3.lerp(path.points[path.currentIndex], path.points[path.currentIndex - 1], coef)\n    }\n\n    for (const pointReached of pointReachedPaths) {\n      const callback = pointReachedCbs.get(pointReached.entity)\n      if (callback) {\n        callback(pointReached.index, pointReached.coords, pointReached.nextCoords)\n      }\n    }\n\n    for (const entity of deadPaths) {\n      const callback = finishCbs.get(entity)\n      unregisterEntity(entity)\n      if (callback)\n        callback()\n    }\n  }\n\n  targetEngine.addSystem(system)\n\n  function startPath(\n    entity: Entity,\n    points: Vector3[],\n    duration: number,\n    faceDirection?: boolean,\n    curveSegmentCount?: number,\n    onFinishCallback?: OnFinishCallback,\n    onPointReachedCallback?: OnPointReachedCallback\n  ) {\n    if (points.length < 2)\n      throw new Error('At least 2 points are required to form a path.')\n\n    if (duration == 0)\n      throw new Error('Path duration must not be zero')\n\n    if (curveSegmentCount) {\n      const loop = Vector3.equals(points[0], points[points.length - 1])\n      if (loop) {\n        points.pop()\n        points.unshift(points.pop()!)\n      }\n      points = createCatmullRomSpline(points, curveSegmentCount, loop)\n    } else {\n      curveSegmentCount = 1\n    }\n\n    finishCbs.set(entity, onFinishCallback)\n    pointReachedCbs.set(entity, onPointReachedCallback)\n\n    let totalLength = 0\n    const segmentLengths = []\n    for (let i = 0; i < points.length - 1; i++) {\n      let sqDist = Vector3.distance(points[i], points[i + 1])\n      totalLength += sqDist\n      segmentLengths.push(sqDist)\n    }\n\n    const segmentTimes = [0]\n    for (let i = 0; i < segmentLengths.length; i++) {\n      segmentTimes.push(segmentLengths[i] / totalLength + segmentTimes[i])\n    }\n\n    FollowPath.createOrReplace(entity, {\n      points: points,\n      segmentTimes: segmentTimes,\n      curveSegmentCount: curveSegmentCount,\n      speed: 1 / duration,\n      normalizedTime: 0,\n      currentIndex: 0,\n      faceDirection: faceDirection\n    })\n  }\n\n  return {\n    startStraightPath(\n      entity: Entity,\n      points: Vector3[],\n      duration: number,\n      faceDirection?: boolean,\n      onFinishCallback?: OnFinishCallback,\n      onPointReachedCallback?: OnPointReachedCallback\n    ) {\n      return startPath(entity, points, duration, faceDirection, 0, onFinishCallback, onPointReachedCallback)\n    },\n    startSmoothPath(\n      entity: Entity,\n      points: Vector3[],\n      duration: number,\n      segmentCount: number,\n      faceDirection?: boolean,\n      onFinishCallback?: OnFinishCallback,\n      onPointReachedCallback?: OnPointReachedCallback\n    ) {\n      if (segmentCount < 2 || !Number.isInteger(segmentCount))\n        throw new Error(`segmentCount must be an integer that is greater than 2, got: ${segmentCount}`)\n      return startPath(entity, points, duration, faceDirection, segmentCount, onFinishCallback, onPointReachedCallback)\n    },\n    stopPath(entity: Entity) {\n      unregisterEntity(entity)\n    },\n    getOnFinishCallback(entity: Entity) {\n      if (!finishCbs.has(entity))\n        throw new Error(`Entity ${entity} is not registered in triggers system`)\n      return finishCbs.get(entity)\n    }\n  }\n}\n\nexport const paths = createPaths(engine)\n"]}

package/dist/utils/utils.d.ts

@@ -0,0 +1,7 @@
+export type DelayedHandle = {
+    id: string;
+    cancel: () => void;
+};
+export declare const delayedFunction: (cb: () => void, delayMs: number) => DelayedHandle;
+export declare function clearDelayedFunction(handleOrId: DelayedHandle | string | undefined | null): void;
+export declare function debugTriggers(): void;

package/dist/utils/utils.js

@@ -0,0 +1,46 @@
+import { engine, MeshRenderer, TriggerArea, Material } from "@dcl/sdk/ecs";
+import { Color4 } from "@dcl/sdk/math";
+let __delayedId = 0;
+export const delayedFunction = (cb, delayMs) => {
+    const id = `delayedFunction_${++__delayedId}`;
+    let timeMs = 0;
+    let cancelled = false;
+    const system = (dt) => {
+        if (cancelled) {
+            engine.removeSystem(id);
+            return;
+        }
+        timeMs += dt * 1000;
+        if (timeMs < delayMs)
+            return;
+        timeMs = 0;
+        engine.removeSystem(id);
+        if (!cancelled) {
+            cb && cb();
+        }
+    };
+    engine.addSystem(system, undefined, id);
+    const cancel = () => {
+        cancelled = true;
+        engine.removeSystem(id);
+    };
+    return { id, cancel };
+};
+export function clearDelayedFunction(handleOrId) {
+    if (!handleOrId)
+        return;
+    if (typeof handleOrId === 'string') {
+        engine.removeSystem(handleOrId);
+        return;
+    }
+    handleOrId.cancel();
+}
+export function debugTriggers() {
+    for (const [entity] of engine.getEntitiesWith(TriggerArea)) {
+        MeshRenderer.setSphere(entity);
+        Material.setPbrMaterial(entity, {
+            albedoColor: Color4.create(1, 0, 0, 0.3)
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUMxRSxPQUFPLEVBQVUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLElBQUksV0FBVyxHQUFHLENBQUMsQ0FBQztBQU9wQixNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsQ0FBQyxFQUFjLEVBQUUsT0FBZSxFQUFpQixFQUFFO0lBQzlFLE1BQU0sRUFBRSxHQUFHLG1CQUFtQixFQUFFLFdBQVcsRUFBRSxDQUFBO0lBQzdDLElBQUksTUFBTSxHQUFHLENBQUMsQ0FBQztJQUNmLElBQUksU0FBUyxHQUFHLEtBQUssQ0FBQztJQUV0QixNQUFNLE1BQU0sR0FBRyxDQUFDLEVBQVUsRUFBRSxFQUFFO1FBQzVCLElBQUksU0FBUyxFQUFFLENBQUM7WUFDZCxNQUFNLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQyxDQUFBO1lBQ3ZCLE9BQU07UUFDUixDQUFDO1FBQ0QsTUFBTSxJQUFJLEVBQUUsR0FBRyxJQUFJLENBQUM7UUFDcEIsSUFBSSxNQUFNLEdBQUcsT0FBTztZQUFFLE9BQU87UUFDN0IsTUFBTSxHQUFHLENBQUMsQ0FBQztRQUNYLE1BQU0sQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDeEIsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2YsRUFBRSxJQUFJLEVBQUUsRUFBRSxDQUFDO1FBQ2IsQ0FBQztJQUNILENBQUMsQ0FBQTtJQUVELE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUV4QyxNQUFNLE1BQU0sR0FBRyxHQUFHLEVBQUU7UUFDbEIsU0FBUyxHQUFHLElBQUksQ0FBQTtRQUNoQixNQUFNLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBQ3pCLENBQUMsQ0FBQTtJQUVELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxFQUFFLENBQUE7QUFDekIsQ0FBQyxDQUFBO0FBRUQsTUFBTSxVQUFVLG9CQUFvQixDQUFDLFVBQXFEO0lBQ3hGLElBQUksQ0FBQyxVQUFVO1FBQUUsT0FBTTtJQUN2QixJQUFJLE9BQU8sVUFBVSxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBRW5DLE1BQU0sQ0FBQyxZQUFZLENBQUMsVUFBVSxDQUFDLENBQUE7UUFDL0IsT0FBTTtJQUNSLENBQUM7SUFDRCxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUE7QUFDckIsQ0FBQztBQUlDLE1BQU0sVUFBVSxhQUFhO0lBRTNCLEtBQUssTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLE1BQU0sQ0FBQyxlQUFlLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztRQUMzRCxZQUFZLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBQzlCLFFBQVEsQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFO1lBQzlCLFdBQVcsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLEdBQUcsQ0FBQztTQUN6QyxDQUFDLENBQUE7SUFDSixDQUFDO0FBSUgsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGVuZ2luZSwgTWVzaFJlbmRlcmVyLCBUcmlnZ2VyQXJlYSwgTWF0ZXJpYWwgfSBmcm9tIFwiQGRjbC9zZGsvZWNzXCJcbmltcG9ydCB7IENvbG9yMywgQ29sb3I0IH0gZnJvbSBcIkBkY2wvc2RrL21hdGhcIjtcblxubGV0IF9fZGVsYXllZElkID0gMDtcblxuZXhwb3J0IHR5cGUgRGVsYXllZEhhbmRsZSA9IHtcbiAgaWQ6IHN0cmluZ1xuICBjYW5jZWw6ICgpID0+IHZvaWRcbn1cblxuZXhwb3J0IGNvbnN0IGRlbGF5ZWRGdW5jdGlvbiA9IChjYjogKCkgPT4gdm9pZCwgZGVsYXlNczogbnVtYmVyKTogRGVsYXllZEhhbmRsZSA9PiB7XG4gICAgY29uc3QgaWQgPSBgZGVsYXllZEZ1bmN0aW9uXyR7KytfX2RlbGF5ZWRJZH1gXG4gICAgbGV0IHRpbWVNcyA9IDA7XG4gICAgbGV0IGNhbmNlbGxlZCA9IGZhbHNlO1xuXG4gICAgY29uc3Qgc3lzdGVtID0gKGR0OiBudW1iZXIpID0+IHtcbiAgICAgIGlmIChjYW5jZWxsZWQpIHtcbiAgICAgICAgZW5naW5lLnJlbW92ZVN5c3RlbShpZClcbiAgICAgICAgcmV0dXJuXG4gICAgICB9XG4gICAgICB0aW1lTXMgKz0gZHQgKiAxMDAwO1xuICAgICAgaWYgKHRpbWVNcyA8IGRlbGF5TXMpIHJldHVybjtcbiAgICAgIHRpbWVNcyA9IDA7XG4gICAgICBlbmdpbmUucmVtb3ZlU3lzdGVtKGlkKTtcbiAgICAgIGlmICghY2FuY2VsbGVkKSB7XG4gICAgICAgIGNiICYmIGNiKCk7XG4gICAgICB9XG4gICAgfVxuXG4gICAgZW5naW5lLmFkZFN5c3RlbShzeXN0ZW0sIHVuZGVmaW5lZCwgaWQpO1xuXG4gICAgY29uc3QgY2FuY2VsID0gKCkgPT4ge1xuICAgICAgY2FuY2VsbGVkID0gdHJ1ZVxuICAgICAgZW5naW5lLnJlbW92ZVN5c3RlbShpZClcbiAgICB9XG5cbiAgICByZXR1cm4geyBpZCwgY2FuY2VsIH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNsZWFyRGVsYXllZEZ1bmN0aW9uKGhhbmRsZU9ySWQ6IERlbGF5ZWRIYW5kbGUgfCBzdHJpbmcgfCB1bmRlZmluZWQgfCBudWxsKSB7XG4gIGlmICghaGFuZGxlT3JJZCkgcmV0dXJuXG4gIGlmICh0eXBlb2YgaGFuZGxlT3JJZCA9PT0gJ3N0cmluZycpIHtcbiAgICAvLyBCZXN0LWVmZm9ydCBjYW5jZWwgYnkgaWQvbmFtZVxuICAgIGVuZ2luZS5yZW1vdmVTeXN0ZW0oaGFuZGxlT3JJZClcbiAgICByZXR1cm5cbiAgfVxuICBoYW5kbGVPcklkLmNhbmNlbCgpXG59XG5cblxuXG4gIGV4cG9ydCBmdW5jdGlvbiBkZWJ1Z1RyaWdnZXJzKCl7XG5cbiAgICBmb3IgKGNvbnN0IFtlbnRpdHldIG9mIGVuZ2luZS5nZXRFbnRpdGllc1dpdGgoVHJpZ2dlckFyZWEpKSB7XG4gICAgICBNZXNoUmVuZGVyZXIuc2V0U3BoZXJlKGVudGl0eSlcbiAgICAgIE1hdGVyaWFsLnNldFBick1hdGVyaWFsKGVudGl0eSwge1xuICAgICAgICBhbGJlZG9Db2xvcjogQ29sb3I0LmNyZWF0ZSgxLCAwLCAwLCAwLjMpXG4gICAgICB9KVxuICAgIH1cblxuXG5cbiAgfSJdfQ==

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "dcl-npc-toolkit",
-  "version": "1.5.2-20250415203310.commit-be60b9e",
+  "version": "1.5.2-20251229114702.commit-02ef366",
   "description": "A collection of tools for creating Non-Player-Characters (NPCs). These are capable of having conversations with the player, and play different animations.",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsc -p tsconfig.json"
+    "build": "tsc -p tsconfig.json",
+    "link-sdk": "cd node_modules/@dcl/sdk && npm link && cd ../js-runtime && npm link"
   },
   "repository": {
     "type": "git",
@@ -26,7 +27,6 @@
   },
   "homepage": "https://github.com/decentraland-scenes/dcl-npc-toolkit#readme",
   "devDependencies": {
-    "@dcl-sdk/utils": "latest",
     "@dcl/sdk": "latest",
     "typescript": "^5.0.2"
   },
@@ -36,5 +36,5 @@
   "dependencies": {
     "@dcl/js-runtime": "latest"
   },
-  "commit": "be60b9e18a389269d3b1b438b4425928eb88226d"
+  "commit": "02ef3662ba4c2304268c2a93c3d758dff97c0197"
 }