dcl-npc-toolkit 0.0.0 → 1.0.5

package/dist/npc.js

@@ -0,0 +1,365 @@
+import { Animator, AvatarShape, Billboard, engine, GltfContainer, MeshCollider, MeshRenderer, pointerEventsSystem, Transform } from '@dcl/sdk/ecs';
+import { Color3, Quaternion, Vector3 } from '@dcl/sdk/math';
+import { NPCPathType, NPCState, NPCType } from './types';
+import * as utils from '@dcl-sdk/utils';
+import { IsFollowingPath } from './components';
+import { handleDialogTyping, handlePathTimes } from './systems';
+import { createDialog } from './ui';
+import { addDialog, closeDialog, npcDialogComponent } from './dialog';
+export const walkingTimers = new Map();
+export const npcDataComponent = new Map();
+export let activeNPC = 0;
+const walkingSystem = engine.addSystem(handlePathTimes);
+const dialogSystem = engine.addSystem(handleDialogTyping);
+const isCooldown = new Map();
+const onActivateCbs = new Map();
+const onWalkAwayCbs = new Map();
+const animTimers = new Map();
+const pointReachedCallbacks = new Map();
+const onFinishCallbacks = new Map();
+export function showDebug(debug) {
+    utils.triggers.enableDebugDraw(debug);
+}
+export function getData(npc) {
+    return npcDataComponent.get(npc);
+}
+export function create(transform, data) {
+    let npc = engine.addEntity();
+    let t = { position: transform.position ? transform.position : Vector3.create(0, 0, 0), rotation: transform.rotation ? transform.rotation : Quaternion.Zero(), scale: transform.scale ? transform.scale : Vector3.One() };
+    Transform.create(npc, t);
+    npcDataComponent.set(npc, {
+        introduced: false,
+        inCooldown: false,
+        coolDownDuration: data && data.coolDownDuration ? data.coolDownDuration : 5,
+        faceUser: data.faceUser,
+        walkingSpeed: 2,
+        walkingAnim: data && data.walkingAnim ? data.walkingAnim : undefined,
+        bubbleHeight: 2,
+        pathData: data.pathData ? data.pathData : undefined,
+        currentPathData: [],
+        manualStop: false,
+        pathIndex: 0,
+        state: NPCState.STANDING
+    });
+    if (data && data.noUI) { }
+    else if (data && data.portrait) { }
+    else {
+        addDialog(npc, data && data.dialogSound ? data.dialogSound : undefined);
+        createDialog(npc);
+    }
+    onActivateCbs.set(npc, () => {
+        data.onActivate();
+    });
+    if (data && data.hasOwnProperty("onWalkAway")) {
+        onWalkAwayCbs.set(npc, () => {
+            if (!data || !data.continueOnWalkAway) {
+                if (npcDialogComponent.has(npc)) {
+                    npcDialogComponent.get(npc).visible = false;
+                }
+            }
+            else {
+                if (npcDialogComponent.has(npc)) {
+                    npcDialogComponent.get(npc).visible = false;
+                }
+            }
+            data.onWalkAway();
+        });
+    }
+    addNPCBones(npc, data);
+    addClickReactions(npc, data);
+    addTriggerArea(npc, data);
+    if (data && data.pathData && data.pathData.speed) {
+        let npcData = npcDataComponent.get(npc);
+        npcData.walkingSpeed = data.pathData.speed;
+    }
+    if (data && data.coolDownDuration) {
+        let npcData = npcDataComponent.get(npc);
+        npcData.coolDownDuration = data.coolDownDuration;
+    }
+    if (data && data.pathData) {
+        let npcData = npcDataComponent.get(npc);
+        followPath(npc, npcData.pathData);
+    }
+    return npc;
+}
+function addNPCBones(npc, data) {
+    switch (data.type) {
+        case NPCType.AVATAR:
+            AvatarShape.create(npc, {
+                id: "npc",
+                name: "NPC",
+                bodyShape: "urn:decentraland:off-chain:base-avatars:BaseMale",
+                emotes: [],
+                wearables: [
+                    "urn:decentraland:off-chain:base-avatars:f_eyes_00",
+                    "urn:decentraland:off-chain:base-avatars:f_eyebrows_00",
+                    "urn:decentraland:off-chain:base-avatars:f_mouth_00",
+                    "urn:decentraland:off-chain:base-avatars:comfy_sport_sandals",
+                    "urn:decentraland:off-chain:base-avatars:soccer_pants",
+                    "urn:decentraland:off-chain:base-avatars:elegant_sweater",
+                ],
+            });
+            break;
+        case NPCType.CUSTOM:
+            GltfContainer.create(npc, {
+                src: data && data.model ? data.model : ""
+            });
+            Animator.create(npc, {
+                states: [{
+                        name: data && data.idleAnim ? data.idleAnim : 'Idle',
+                        clip: data && data.idleAnim ? data.idleAnim : 'Idle',
+                        loop: true
+                    }]
+            });
+            npcDataComponent.get(npc).idleAnim = data && data.idleAnim ? data.idleAnim : 'Idle';
+            Animator.playSingleAnimation(npc, npcDataComponent.get(npc).idleAnim);
+            let npcData = npcDataComponent.get(npc);
+            npcData.lastPlayedAnim = npcDataComponent.get(npc).idleAnim;
+            if (data && data.walkingAnim) {
+                npcDataComponent.get(npc).walkingAnim = data.walkingAnim;
+                let animations = Animator.getMutable(npc);
+                animations.states.push({ name: data.walkingAnim, clip: data.walkingAnim, loop: true });
+            }
+            break;
+        case NPCType.BLANK:
+            MeshRenderer.setBox(npc);
+            MeshCollider.setBox(npc);
+            break;
+    }
+}
+function addClickReactions(npc, data) {
+    let activateButton = data && data.onlyClickTrigger ? 0 : 1;
+    pointerEventsSystem.onPointerDown(npc, function () {
+        if (isCooldown.has(npc) || (npcDialogComponent.get(npc).visible))
+            return;
+        activate(npc);
+    }, {
+        button: activateButton,
+        hoverText: data && data.hoverText ? data.hoverText : 'Talk',
+        showFeedback: data && data.onlyExternalTrigger ? false : true,
+    });
+    if (data && data.onlyExternalTrigger) {
+        pointerEventsSystem.removeOnPointerDown(npc);
+    }
+}
+function addTriggerArea(npc, data) {
+    let triggerData = {};
+    if (!data || (data && !data.onlyExternalTrigger && !data.onlyClickTrigger && !data.onlyETrigger)) {
+        onActivateCbs.set(npc, () => {
+            if (isCooldown.has(npc)) {
+                console.log(npc, ' in cooldown');
+                return;
+            }
+            else if ((npcDialogComponent.has(npc) && npcDialogComponent.get(npc).visible) ||
+                (data && data.onlyExternalTrigger) ||
+                (data && data.onlyClickTrigger)) {
+                return;
+            }
+            data.onActivate();
+        });
+        triggerData.onCameraEnter = onActivateCbs.get(npc);
+    }
+    if (!data || (data && !data.continueOnWalkAway)) {
+        triggerData.onCameraExit = () => {
+            handleWalkAway(npc);
+        };
+    }
+    if (!data ||
+        (data && !data.onlyExternalTrigger && !data.onlyClickTrigger && !data.onlyETrigger)) {
+        triggerData.onCameraEnter = () => {
+            if (isCooldown.has(npc)) {
+                console.log(npc, ' in cooldown');
+                return;
+            }
+            activate(npc);
+        };
+    }
+    if (triggerData.onCameraEnter || triggerData.onCameraExit) {
+        utils.triggers.addTrigger(npc, 254, 1, [{ type: 'sphere', position: Vector3.Zero(), radius: data.reactDistance != undefined ? data.reactDistance : 6 }], triggerData.onCameraEnter ? triggerData.onCameraEnter : undefined, triggerData.onCameraExit ? triggerData.onCameraExit : undefined, Color3.Red());
+    }
+}
+export function followPath(npc, data) {
+    let npcData = npcDataComponent.get(npc);
+    let path = [];
+    if (data) {
+        npcData.pathData = data;
+        if (npcData.faceUser) {
+            Billboard.deleteFrom(npc);
+        }
+        if (data.startingPoint) {
+            data.path?.splice(0, data.startingPoint - 1);
+        }
+        let pos = Transform.get(npc).position;
+        path.push(Vector3.create(pos.x, pos.y, pos.z));
+        data.path?.forEach((p) => {
+            path.push(p);
+        });
+        onFinishCallbacks.set(npc, () => {
+            console.log('on finished callback');
+            if (data && data.onFinishCallback && !data.loop) {
+                data.onFinishCallback;
+            }
+            stopPath(npc);
+        });
+        pointReachedCallbacks.set(npc, () => {
+            console.log('on point reached callback');
+            let data = npcDataComponent.get(npc);
+            data.pathIndex += 1;
+            data.onReachedPointCallback ? data.onReachedPointCallback : undefined;
+        });
+        walkNPC(npc, npcData, data.pathType, data.totalDuration, path, pointReachedCallbacks.get(npc), onFinishCallbacks.get(npc));
+    }
+    else {
+        if (npcData.manualStop) {
+            console.log('we have manual stop, need to pick back up where we left off');
+        }
+        else {
+            console.log('we are trying to follow a path witout starting one prior');
+        }
+    }
+}
+function walkNPC(npc, npcData, type, duration, path, pointReachedCallback, finishedCallback) {
+    if (IsFollowingPath.has(npc)) {
+        IsFollowingPath.deleteFrom(npc);
+        walkingTimers.delete(npc);
+    }
+    IsFollowingPath.create(npc);
+    if (type) {
+        if (type == NPCPathType.RIGID_PATH) {
+            utils.paths.startStraightPath(npc, path, duration, true, () => { finishedCallback(); }, () => { pointReachedCallback(); });
+        }
+        else {
+            utils.paths.startSmoothPath(npc, path, duration, 30, true, () => { finishedCallback(); }, () => { pointReachedCallback(); });
+        }
+    }
+    else {
+        utils.paths.startSmoothPath(npc, path, duration, 20, true, () => { finishedCallback(); }, () => { pointReachedCallback(); });
+    }
+    if (npcData.walkingAnim) {
+        Animator.playSingleAnimation(npc, npcDataComponent.get(npc).walkingAnim, true);
+        npcData.lastPlayedAnim = npcDataComponent.get(npc).walkingAnim;
+    }
+    npcData.state = NPCState.FOLLOWPATH;
+    console.log('debug here');
+}
+export function stopWalking(npc, duration, finished) {
+    let npcData = npcDataComponent.get(npc);
+    npcData.state = NPCState.STANDING;
+    npcData.manualStop = true;
+    stopPath(npc);
+    if (duration) {
+        utils.timers.setTimeout(() => {
+            if (npcData.path) {
+                Animator.stopAllAnimations(npc, true);
+                if (npcDataComponent.get(npc).walkingAnim) {
+                    Animator.playSingleAnimation(npc, npcDataComponent.get(npc).walkingAnim, true);
+                    npcData.lastPlayedAnim = npcDataComponent.get(npc).walkingAnim;
+                }
+                let duration = npcData.pathData.totalDuration;
+                let currentTimer = walkingTimers.get(npc);
+                console.log('current time is', currentTimer);
+                if (currentTimer) {
+                    duration -= currentTimer;
+                }
+                let path = [];
+                npcData.pathData.path.forEach((p) => {
+                    path.push(p);
+                });
+                path.splice(0, npcData.pathIndex);
+                let pos = Transform.get(npc).position;
+                path.unshift(Vector3.create(pos.x, pos.y, pos.z));
+                npcData.manualStop = false;
+                walkNPC(npc, npcData, npcData.pathData.pathType, duration, path, pointReachedCallbacks.get(npc), onFinishCallbacks.get(npc));
+            }
+        }, duration * 1000);
+    }
+}
+function stopPath(npc) {
+    utils.paths.stopPath(npc);
+    IsFollowingPath.deleteFrom(npc);
+    let npcData = npcDataComponent.get(npc);
+    if (npcData.walkingAnim) {
+        Animator.playSingleAnimation(npc, npcDataComponent.get(npc).walkingAnim);
+        npcData.lastPlayedAnim = npcData.idleAnim;
+    }
+    if (!npcData.manualStop) {
+        if (npcData.pathData.loop) {
+            npcData.pathIndex = 0;
+            walkingTimers.delete(npc);
+            console.log('we are looping path', npcData);
+            followPath(npc, npcData.pathData);
+            console.log(npcData);
+        }
+    }
+}
+export function activate(npc) {
+    activeNPC = npc;
+    onActivateCbs.get(npc)();
+    let npcData = npcDataComponent.get(npc);
+    if (npcData.faceUser) {
+        Billboard.create(npc, {
+            billboardMode: 2
+        });
+    }
+    isCooldown.set(npc, true);
+    npcData.inCooldown = true;
+    utils.timers.setTimeout(function () {
+        isCooldown.delete(npc);
+        npcDataComponent.get(npc).inCooldown = false;
+        if (Billboard.has(npc)) {
+            Billboard.deleteFrom(npc);
+        }
+    }, 1000 * npcData.coolDownDuration);
+    console.log('activated npc,', npcDataComponent.get(npc));
+}
+function endInteraction(npc) {
+    let npcData = npcDataComponent.get(npc);
+    npcData.state = NPCState.STANDING;
+    if (npcDialogComponent.has(npc) && npcDialogComponent.get(npc).visible) {
+        closeDialog(npc);
+    }
+    if (npcData.faceUser) {
+        Billboard.deleteFrom(npc);
+    }
+}
+export function handleWalkAway(npc) {
+    let npcData = npcDataComponent.get(npc);
+    if (npcData.state == NPCState.FOLLOWPATH) {
+        return;
+    }
+    endInteraction(npc);
+    if (onWalkAwayCbs.get(npc)) {
+        onWalkAwayCbs.get(npc)();
+    }
+}
+export function playAnimation(npc, anim, noLoop, duration) {
+    let animations = Animator.getMutable(npc);
+    if (animations.states.filter((animation) => animation.name === anim).length == 0) {
+        animations.states.push({ name: anim, clip: anim, loop: noLoop ? false : true });
+    }
+    let npcData = npcDataComponent.get(npc);
+    if (npcData.state == NPCState.FOLLOWPATH) {
+        utils.paths.stopPath(npc);
+    }
+    if (animTimers.has(npc)) {
+        utils.timers.clearTimeout(animTimers.get(npc));
+        animTimers.delete(npc);
+    }
+    Animator.stopAllAnimations(npc);
+    Animator.playSingleAnimation(npc, anim, true);
+    if (duration) {
+        animTimers.set(npc, utils.timers.setTimeout(() => {
+            animTimers.delete(npc);
+        }, 1000 * duration));
+    }
+    npcData.lastPlayedAnim = anim;
+}
+export function changeIdleAnim(npc, animation, play) {
+    let npcData = npcDataComponent.get(npc);
+    npcData.idleAnim = animation;
+    if (play) {
+        playAnimation(npc, animation, true);
+        npcDataComponent.get(npc).lastPlayedAnim = animation;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"npc.js","sourceRoot":"","sources":["../src/npc.ts"],"names":[],"mappings":"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","sourcesContent":["import { Animator, AvatarShape, Billboard, BillboardMode, engine, Entity, GltfContainer, InputAction,MeshCollider,MeshRenderer,pointerEventsSystem,Transform, TransformType } from '@dcl/sdk/ecs'\nimport { Color3, Quaternion, Vector3 } from '@dcl/sdk/math'\nimport { FollowPathData, NPCData, NPCPathType, NPCState, NPCType, TriggerData } from './types';\nimport * as utils from '@dcl-sdk/utils'\nimport { IsFollowingPath } from './components';\nimport { handleDialogTyping, handlePathTimes } from './systems';\nimport { createDialog } from './ui';\nimport { addDialog, closeDialog, npcDialogComponent } from './dialog';\n\nexport const walkingTimers: Map<Entity,number> = new Map()\nexport const npcDataComponent: Map<Entity, any> = new Map()\nexport let activeNPC:number = 0\n\nconst walkingSystem = engine.addSystem(handlePathTimes)\nconst dialogSystem = engine.addSystem(handleDialogTyping)\n\nconst isCooldown: Map<Entity, any> = new Map()\nconst onActivateCbs: Map<Entity, any> = new Map()\nconst onWalkAwayCbs: Map<Entity, any> = new Map()\nconst animTimers: Map<Entity,any> = new Map()\nconst pointReachedCallbacks: Map<Entity, any> = new Map()\nconst onFinishCallbacks: Map<Entity, any> = new Map()\n\nexport function showDebug(debug:boolean){\n    utils.triggers.enableDebugDraw(debug)\n}\n\nexport function getData(npc:Entity){\n    return npcDataComponent.get(npc)\n}\n\nexport function create(\n    transform: any,\n    data: NPCData\n){\n    let npc = engine.addEntity()\n\n    let t:TransformType = {position: transform.position ? transform.position : Vector3.create(0,0,0), rotation: transform.rotation ? transform.rotation : Quaternion.Zero(), scale: transform.scale ? transform.scale : Vector3.One()}\n    Transform.create(npc, t)\n\n    npcDataComponent.set(npc,{\n        introduced: false,\n        inCooldown: false,\n        coolDownDuration: data && data.coolDownDuration ? data.coolDownDuration : 5,\n        faceUser:data.faceUser,\n        walkingSpeed:2,\n        walkingAnim: data && data.walkingAnim ? data.walkingAnim : undefined,\n        bubbleHeight:2,\n        pathData: data.pathData ? data.pathData : undefined,\n        currentPathData: [],\n        manualStop:false,\n        pathIndex:0,\n        state:NPCState.STANDING\n    })\n\n    if(data && data.noUI){}\n    else if(data && data.portrait){}\n    else{\n        addDialog(npc, data && data.dialogSound ? data.dialogSound : undefined)\n        createDialog(npc)\n    }\n\n    onActivateCbs.set(npc, ()=>{\n        data.onActivate()\n    })\n\n    if (data && data.hasOwnProperty(\"onWalkAway\")) {\n        onWalkAwayCbs.set(npc, ()=>{\n            if(!data || !data.continueOnWalkAway){\n                if(npcDialogComponent.has(npc)){\n                    npcDialogComponent.get(npc).visible = false\n                }\n            }\n            else{\n                if(npcDialogComponent.has(npc)){\n                    npcDialogComponent.get(npc).visible = false\n                }\n            }\n            data.onWalkAway!()\n        })\n    }\n\n    addNPCBones(npc, data)\n    addClickReactions(npc, data)\n    addTriggerArea(npc, data)\n    \n    if (data && data.pathData && data.pathData.speed) {\n        let npcData = npcDataComponent.get(npc)\n        npcData.walkingSpeed = data.pathData.speed\n    }\n\n    if (data && data.coolDownDuration) {\n        let npcData = npcDataComponent.get(npc)\n        npcData.coolDownDuration = data.coolDownDuration\n    }\n\n    if (data && data.pathData){\n        let npcData = npcDataComponent.get(npc)\n        //npcData.currentPathData = npcData.pathData\n        followPath(npc, npcData.pathData)\n    }\n\n    return npc\n}\n\nfunction addNPCBones(npc:Entity, data:NPCData){\n    switch(data.type){\n        case NPCType.AVATAR:\n            AvatarShape.create(npc, {\n                id: \"npc\",\n                name: \"NPC\",\n                bodyShape:\"urn:decentraland:off-chain:base-avatars:BaseMale\",\n                emotes: [],\n                wearables: [\n                    \"urn:decentraland:off-chain:base-avatars:f_eyes_00\",\n                    \"urn:decentraland:off-chain:base-avatars:f_eyebrows_00\",\n                    \"urn:decentraland:off-chain:base-avatars:f_mouth_00\",\n                    \"urn:decentraland:off-chain:base-avatars:comfy_sport_sandals\",\n                    \"urn:decentraland:off-chain:base-avatars:soccer_pants\",\n                    \"urn:decentraland:off-chain:base-avatars:elegant_sweater\",\n                    ],\n            })\n            break;\n\n        case NPCType.CUSTOM:\n            GltfContainer.create(npc, { \n                src: data && data.model ? data.model : \"\" \n            })\n            Animator.create(npc, {\n                states:[{\n                    name:data && data.idleAnim ? data.idleAnim : 'Idle',\n                    clip:data && data.idleAnim ? data.idleAnim : 'Idle',\n                    loop:true\n                }]\n            })\n\n            npcDataComponent.get(npc).idleAnim = data && data.idleAnim ? data.idleAnim : 'Idle'\n            Animator.playSingleAnimation(npc, npcDataComponent.get(npc).idleAnim)\n\n            let npcData = npcDataComponent.get(npc)\n            npcData.lastPlayedAnim = npcDataComponent.get(npc).idleAnim\n\n            if (data && data.walkingAnim) {\n                npcDataComponent.get(npc).walkingAnim = data.walkingAnim\n                let animations = Animator.getMutable(npc)\n                animations.states.push({name:data.walkingAnim, clip: data.walkingAnim, loop:true})\n            }\n\n            break;\n\n        case NPCType.BLANK:\n            MeshRenderer.setBox(npc)\n            MeshCollider.setBox(npc)\n            break;\n\n    }\n}\n\nfunction addClickReactions(npc:Entity, data:NPCData){\n    let activateButton = data && data.onlyClickTrigger ? InputAction.IA_POINTER : InputAction.IA_PRIMARY\n\n    pointerEventsSystem.onPointerDown(\n        npc,\n        function () {\n            if (isCooldown.has(npc) || (npcDialogComponent.get(npc).visible)) return\n            activate(npc)\n        },\n        {\n            button: activateButton,\n            hoverText: data && data.hoverText ? data.hoverText : 'Talk',\n            showFeedback: data && data.onlyExternalTrigger ? false : true,\n        }\n        )\n\n        if (data && data.onlyExternalTrigger) {\n        pointerEventsSystem.removeOnPointerDown(npc)\n        } \n}\n\nfunction addTriggerArea(npc:Entity, data:NPCData){\n\n        let triggerData: TriggerData = {}\n\n        if (!data || (data && !data.onlyExternalTrigger && !data.onlyClickTrigger && !data.onlyETrigger)){\n        onActivateCbs.set(npc, ()=>{\n            if (isCooldown.has(npc)) {\n                console.log(npc, ' in cooldown')\n                return\n            } \n            else if (\n                (npcDialogComponent.has(npc) && npcDialogComponent.get(npc).visible) ||\n                (data && data.onlyExternalTrigger) ||\n                (data && data.onlyClickTrigger)\n            ) {\n                return\n            }\n            data.onActivate()\n        })\n        triggerData.onCameraEnter = onActivateCbs.get(npc)\n        }\n\n    // when exiting trigger\n    if (!data || (data && !data.continueOnWalkAway)) {\n        triggerData.onCameraExit = () => {\n            handleWalkAway(npc)\n        }\n    }\n\n    // when entering trigger\n    if (\n        !data ||\n        (data && !data.onlyExternalTrigger && !data.onlyClickTrigger && !data.onlyETrigger)\n    ) {\n        triggerData.onCameraEnter = () => {\n            if (isCooldown.has(npc)) {\n                console.log(npc, ' in cooldown')\n                return\n            } \n            // else if (\n            //     (this.dialog && this.dialog.isDialogOpen) ||\n            //     (data && data.onlyExternalTrigger) ||\n            //     (data && data.onlyClickTrigger)\n            // ) {\n            //     return\n            // }\n            activate(npc)\n        }\n    }\n\n    // add trigger\n    if (triggerData.onCameraEnter || triggerData.onCameraExit) {\n        utils.triggers.addTrigger(npc,254,1,[{type:'sphere', position: Vector3.Zero(), radius: data.reactDistance != undefined ? data.reactDistance : 6}], triggerData.onCameraEnter ? triggerData.onCameraEnter : undefined, triggerData.onCameraExit ? triggerData.onCameraExit : undefined, Color3.Red())\n    }\n}\n\nexport function followPath(npc:Entity, data?:FollowPathData){\n        \n    let npcData = npcDataComponent.get(npc)\n    let path:any[] =[]\n\n    if(data){\n        npcData.pathData = data\n\n        if(npcData.faceUser){\n            Billboard.deleteFrom(npc)\n        }\n\n        if(data.startingPoint){\n            data.path?.splice(0,data.startingPoint - 1)\n        }\n\n        let pos = Transform.get(npc).position\n        path.push(Vector3.create(pos.x, pos.y, pos.z))\n        data.path?.forEach((p)=>{\n            path.push(p)\n        })\n\n        onFinishCallbacks.set(npc,()=>{\n            console.log('on finished callback')\n            if(data && data.onFinishCallback && !data.loop){\n                data.onFinishCallback\n            }\n            stopPath(npc)\n        })\n\n        pointReachedCallbacks.set(npc, ()=>{\n            console.log('on point reached callback')\n            let data = npcDataComponent.get(npc)\n            data.pathIndex += 1\n            data.onReachedPointCallback ? data.onReachedPointCallback : undefined\n        })\n        walkNPC(npc, npcData, data.pathType!, data.totalDuration, path, pointReachedCallbacks.get(npc), onFinishCallbacks.get(npc))\n    }else{\n        if(npcData.manualStop){\n            console.log('we have manual stop, need to pick back up where we left off')\n        }\n        else{\n            console.log('we are trying to follow a path witout starting one prior')\n        }\n    }\n    }\n//\nfunction walkNPC(npc:Entity, npcData:any, type:NPCPathType, duration:number, path:Vector3[], pointReachedCallback?:any, finishedCallback?:any){\n    //\n    if(IsFollowingPath.has(npc)){\n        IsFollowingPath.deleteFrom(npc)\n        walkingTimers.delete(npc)\n    }\n    IsFollowingPath.create(npc)\n\n    if(type){\n        if(type== NPCPathType.RIGID_PATH){\n            utils.paths.startStraightPath(npc, path, duration,true,\n                ()=>{finishedCallback()}, ()=>{pointReachedCallback()})\n        }\n        else{\n            utils.paths.startSmoothPath(npc, path, duration, 30, true, \n                ()=>{finishedCallback()}, ()=>{pointReachedCallback()})\n            }\n    }\n    else{\n        utils.paths.startSmoothPath(npc, path, duration, 20, true, \n            ()=>{finishedCallback()}, ()=>{pointReachedCallback()})\n    }   \n\n    if (npcData.walkingAnim) {\n        // if (this.endAnimTimer.hasComponent(NPCDelay)) {\n        //   this.endAnimTimer.removeComponent(NPCDelay)\n        // }\n        Animator.playSingleAnimation(npc, npcDataComponent.get(npc).walkingAnim, true)\n        npcData.lastPlayedAnim = npcDataComponent.get(npc).walkingAnim\n      }\n    npcData.state = NPCState.FOLLOWPATH\n    console.log('debug here')\n}\n\nexport function stopWalking(npc:Entity, duration?: number, finished?:boolean) {\n    let npcData = npcDataComponent.get(npc)\n    npcData.state = NPCState.STANDING\n    npcData.manualStop = true\n\n    stopPath(npc)\n\n    if (duration) {\n        utils.timers.setTimeout(()=>{\n            //if (this.dialog && this.dialog.isDialogOpen) return\n            if(npcData.path){\n                Animator.stopAllAnimations(npc, true)\n                if(npcDataComponent.get(npc).walkingAnim){\n                    Animator.playSingleAnimation(npc, npcDataComponent.get(npc).walkingAnim,true)\n                    npcData.lastPlayedAnim = npcDataComponent.get(npc).walkingAnim\n                }\n                let duration = npcData.pathData.totalDuration\n                let currentTimer:number = walkingTimers.get(npc)!\n                console.log('current time is', currentTimer)\n                if(currentTimer){\n                    duration -= currentTimer\n                }\n    \n                let path:any[] = []\n                npcData.pathData.path.forEach((p:any)=>{\n                    path.push(p)\n                })\n                path.splice(0,npcData.pathIndex)\n    \n                let pos = Transform.get(npc).position\n                path.unshift(Vector3.create(pos.x, pos.y, pos.z))\n    \n                npcData.manualStop = false\n                walkNPC(npc,npcData, npcData.pathData.pathType, duration, path, pointReachedCallbacks.get(npc), onFinishCallbacks.get(npc))    \n            }\n\n        },duration * 1000)\n    }\n}//\n\nfunction stopPath(npc:Entity){\n    utils.paths.stopPath(npc)\n    IsFollowingPath.deleteFrom(npc)\n\n    let npcData = npcDataComponent.get(npc)\n    if (npcData.walkingAnim) {\n        Animator.playSingleAnimation(npc, npcDataComponent.get(npc).walkingAnim)\n        npcData.lastPlayedAnim = npcData.idleAnim\n    }\n\n    if(!npcData.manualStop){\n        if(npcData.pathData.loop){\n            npcData.pathIndex = 0\n            walkingTimers.delete(npc)\n            console.log('we are looping path', npcData)\n            followPath(npc, npcData.pathData)\n            console.log(npcData)\n        }\n    }\n}\n\n/**\n * Calls the NPC's activation function (set on NPC definition). If NPC has `faceUser` = true, it will rotate to face the player. It starts a cooldown counter to avoid reactivating.\n */\nexport function activate(npc:Entity) {\n    activeNPC = npc\n    onActivateCbs.get(npc)()\n\n    let npcData = npcDataComponent.get(npc)\n    if (npcData.faceUser) {\n        Billboard.create(npc, {\n            billboardMode:BillboardMode.BM_Y\n        })\n    }\n    isCooldown.set(npc, true)\n    npcData.inCooldown = true\n\n    utils.timers.setTimeout(\n        function() {\n            isCooldown.delete(npc)\n            npcDataComponent.get(npc).inCooldown = false\n            if(Billboard.has(npc)){\n                Billboard.deleteFrom(npc)\n            }\n        },\n        1000 * npcData.coolDownDuration\n    )\n    console.log('activated npc,', npcDataComponent.get(npc))\n}\n\nfunction endInteraction(npc:Entity) {\n     let npcData = npcDataComponent.get(npc)\n     npcData.state = NPCState.STANDING\n\n        if (npcDialogComponent.has(npc) && npcDialogComponent.get(npc).visible) {\n            closeDialog(npc)\n        }\n\n        if(npcData.faceUser){\n            Billboard.deleteFrom(npc)\n        }\n\n    // if (this.bubble && this.bubble.isBubleOpen) {\n    //   this.bubble.closeDialogWindow()\n    // }\n}\n\n/**\n * Ends interaction and calls the onWalkAway function\n */\nexport function handleWalkAway(npc:Entity) {\n    let npcData = npcDataComponent.get(npc)\n    if (npcData.state == NPCState.FOLLOWPATH) {\n        return\n    }\n\n    endInteraction(npc)\n\n    if (onWalkAwayCbs.get(npc)) {\n        onWalkAwayCbs.get(npc)()\n    }\n}\n\nexport function playAnimation(npc:Entity, anim:string, noLoop?:boolean, duration?:number){\n    let animations = Animator.getMutable(npc)\n    if(animations.states.filter((animation)=> animation.name === anim).length == 0){\n        animations.states.push({name:anim, clip:anim, loop: noLoop? false : true})\n    }\n\n    let npcData = npcDataComponent.get(npc)\n    if(npcData.state == NPCState.FOLLOWPATH){\n        utils.paths.stopPath(npc)\n    }\n\n    if(animTimers.has(npc)){\n        utils.timers.clearTimeout(animTimers.get(npc))\n        animTimers.delete(npc)\n    }\n\n    Animator.stopAllAnimations(npc)\n    Animator.playSingleAnimation(npc, anim, true)\n    if(duration){\n        animTimers.set(npc, utils.timers.setTimeout(()=>{\n            animTimers.delete(npc)\n        }, 1000 * duration))\n    } \n\n    npcData.lastPlayedAnim = anim\n}\n\nexport function changeIdleAnim(npc:Entity, animation:string, play?:boolean){\n    let npcData = npcDataComponent.get(npc)\n    npcData.idleAnim = animation\n    if(play){\n        playAnimation(npc, animation, true)\n        npcDataComponent.get(npc).lastPlayedAnim = animation\n    }\n}"]}

package/dist/npcData.d.ts

@@ -0,0 +1,13 @@
+export declare const NPCDataComponent: import("@dcl/sdk/ecs").MapComponentDefinition<import("@dcl/sdk/ecs").MapResult<{
+    introduced: import("@dcl/sdk/ecs").ISchema<boolean>;
+    inCooldown: import("@dcl/sdk/ecs").ISchema<boolean>;
+    coolDownDuration: import("@dcl/sdk/ecs").ISchema<number>;
+    faceUser: import("@dcl/sdk/ecs").ISchema<boolean>;
+    walkingSpeed: import("@dcl/sdk/ecs").ISchema<number>;
+    bubbleHeight: import("@dcl/sdk/ecs").ISchema<number>;
+    state: import("@dcl/sdk/ecs").ISchema<string>;
+    walkingAnim: import("@dcl/sdk/ecs").ISchema<string>;
+    idleAnim: import("@dcl/sdk/ecs").ISchema<string>;
+    lastPlayedAnim: import("@dcl/sdk/ecs").ISchema<string>;
+    path: import("@dcl/sdk/ecs").ISchema<import("@dcl/sdk/ecs").Vector3Type[]>;
+}>>;

package/dist/npcData.js

@@ -0,0 +1,15 @@
+import { Schemas, engine } from "@dcl/sdk/ecs";
+export const NPCDataComponent = engine.defineComponent("npcdatacomponent", {
+    introduced: Schemas.Boolean,
+    inCooldown: Schemas.Boolean,
+    coolDownDuration: Schemas.Number,
+    faceUser: Schemas.Boolean,
+    walkingSpeed: Schemas.Number,
+    bubbleHeight: Schemas.Number,
+    state: Schemas.String,
+    walkingAnim: Schemas.String,
+    idleAnim: Schemas.String,
+    lastPlayedAnim: Schemas.String,
+    path: Schemas.Array(Schemas.Vector3)
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBjRGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9ucGNEYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQy9DLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLE1BQU0sQ0FBQyxlQUFlLENBQ3JELGtCQUFrQixFQUNsQjtJQUNDLFVBQVUsRUFBRSxPQUFPLENBQUMsT0FBTztJQUMzQixVQUFVLEVBQUUsT0FBTyxDQUFDLE9BQU87SUFDckIsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLE1BQU07SUFDaEMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxPQUFPO0lBQ3pCLFlBQVksRUFBRSxPQUFPLENBQUMsTUFBTTtJQUM1QixZQUFZLEVBQUUsT0FBTyxDQUFDLE1BQU07SUFDNUIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxNQUFNO0lBQ3JCLFdBQVcsRUFBRSxPQUFPLENBQUMsTUFBTTtJQUMzQixRQUFRLEVBQUUsT0FBTyxDQUFDLE1BQU07SUFDeEIsY0FBYyxFQUFFLE9BQU8sQ0FBQyxNQUFNO0lBQzlCLElBQUksRUFBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUM7Q0FDekMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NoZW1hcywgZW5naW5lIH0gZnJvbSBcIkBkY2wvc2RrL2Vjc1wiO1xuZXhwb3J0IGNvbnN0IE5QQ0RhdGFDb21wb25lbnQgPSBlbmdpbmUuZGVmaW5lQ29tcG9uZW50KFxuXHRcIm5wY2RhdGFjb21wb25lbnRcIixcblx0e1xuXHRcdGludHJvZHVjZWQ6IFNjaGVtYXMuQm9vbGVhbixcblx0XHRpbkNvb2xkb3duOiBTY2hlbWFzLkJvb2xlYW4sXG4gICAgICAgIGNvb2xEb3duRHVyYXRpb246IFNjaGVtYXMuTnVtYmVyLFxuICAgICAgICBmYWNlVXNlcjogU2NoZW1hcy5Cb29sZWFuLFxuICAgICAgICB3YWxraW5nU3BlZWQ6IFNjaGVtYXMuTnVtYmVyLFxuICAgICAgICBidWJibGVIZWlnaHQ6IFNjaGVtYXMuTnVtYmVyLFxuICAgICAgICBzdGF0ZTogU2NoZW1hcy5TdHJpbmcsXG4gICAgICAgIHdhbGtpbmdBbmltOiBTY2hlbWFzLlN0cmluZyxcbiAgICAgICAgaWRsZUFuaW06IFNjaGVtYXMuU3RyaW5nLFxuICAgICAgICBsYXN0UGxheWVkQW5pbTogU2NoZW1hcy5TdHJpbmcsXG4gICAgICAgIHBhdGg6U2NoZW1hcy5BcnJheShTY2hlbWFzLlZlY3RvcjMpXG5cdH0pIl19

package/dist/systems.d.ts

@@ -0,0 +1,2 @@
+export declare function handlePathTimes(dt: number): void;
+export declare function handleDialogTyping(dt: number): void;

package/dist/systems.js

@@ -0,0 +1,37 @@
+import { engine } from "@dcl/sdk/ecs";
+import { IsFollowingPath, IsTypingDialog } from "./components";
+import { walkingTimers } from "./npc";
+import { npcDialogComponent } from "./dialog";
+export function handlePathTimes(dt) {
+    for (const [entity] of engine.getEntitiesWith(IsFollowingPath)) {
+        if (walkingTimers.has(entity)) {
+            let elapsed = walkingTimers.get(entity);
+            elapsed += dt;
+            walkingTimers.set(entity, walkingTimers.get(entity) + dt);
+        }
+        else {
+            walkingTimers.set(entity, dt);
+        }
+    }
+}
+export function handleDialogTyping(dt) {
+    for (const [entity] of engine.getEntitiesWith(IsTypingDialog)) {
+        let dialogData = npcDialogComponent.get(entity);
+        if (!dialogData.typing) {
+            return;
+        }
+        dialogData.timer += dt;
+        if (dialogData.timer >= 2 / dialogData.speed) {
+            let charsToAdd = Math.floor(dialogData.timer / (1 / dialogData.speed));
+            dialogData.timer = 0;
+            dialogData.visibleChars += charsToAdd;
+            if (dialogData.visibleChars >= dialogData.fullText.length) {
+                dialogData.typing = false;
+                dialogData.visibleChars = dialogData.fullText.length;
+                IsTypingDialog.deleteFrom(entity);
+            }
+            dialogData.visibleText = dialogData.fullText.substr(0, dialogData.visibleChars);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types.d.ts

@@ -0,0 +1,119 @@
+import { Vector3 } from "@dcl/sdk/math";
+export type Dialog = {
+    text: string;
+    name?: string;
+    fontSize?: number;
+    offsetX?: number;
+    offsetY?: number;
+    typeSpeed?: number;
+    isEndOfDialog?: boolean;
+    triggeredByNext?: () => void;
+    portrait?: ImageData;
+    image?: ImageData;
+    isQuestion?: boolean;
+    isFixedScreen?: boolean;
+    buttons?: ButtonData[];
+    audio?: string;
+    skipable?: boolean;
+    timeOn?: number;
+};
+export type TriggerData = {
+    layer?: number;
+    triggeredByLayer?: number;
+    onTriggerEnter?: () => void;
+    onTriggerExit?: () => void;
+    onCameraEnter?: () => void;
+    onCameraExit?: () => void;
+    enableDebug?: boolean;
+};
+export type ButtonData = {
+    goToDialog: number | string;
+    label: string;
+    triggeredActions?: () => void;
+    fontSize?: number;
+    offsetX?: number;
+    offsetY?: number;
+};
+export declare enum ButtonStyles {
+    E = "e",
+    F = "f",
+    DARK = "dark",
+    RED = "red",
+    ROUNDBLACK = "roundblack",
+    ROUNDWHITE = "roundwhite",
+    ROUNDSILVER = "roundsilver",
+    ROUNDGOLD = "roundgold",
+    SQUAREBLACK = "squareblack",
+    SQUAREWHITE = "squarewhite",
+    SQUARESILVER = "squaresilver",
+    SQUAREGOLD = "squaregold",
+    WHITE = "white"
+}
+export type NPCData = {
+    type: NPCType;
+    body?: NPCBodyType;
+    model?: string;
+    walkingAnim?: string;
+    portrait?: string | ImageData;
+    reactDistance?: number;
+    idleAnim?: string;
+    faceUser?: boolean;
+    turningSpeed?: number;
+    onlyExternalTrigger?: boolean;
+    onlyClickTrigger?: boolean;
+    onlyETrigger?: boolean;
+    onActivate: () => void;
+    onWalkAway?: () => void;
+    continueOnWalkAway?: boolean;
+    darkUI?: boolean;
+    coolDownDuration?: number;
+    hoverText?: string;
+    dialogSound?: string;
+    textBubble?: boolean;
+    bubbleHeight?: number;
+    noUI?: boolean;
+    pathData?: FollowPathData;
+};
+export type FollowPathData = {
+    startingPoint?: number;
+    loop?: boolean;
+    curve?: boolean;
+    totalDuration: number;
+    speed?: number;
+    path?: Vector3[];
+    pathType?: NPCPathType;
+    onFinishCallback?: () => void;
+    onReachedPointCallback?: () => void;
+};
+export type ImageSection = {
+    sourceWidth: number;
+    sourceHeight: number;
+    sourceLeft?: number;
+    sourceTop?: number;
+};
+export type ImageData = {
+    path: string;
+    offsetX?: number;
+    offsetY?: number;
+    height?: number;
+    width?: number;
+    section?: ImageSection;
+};
+export declare enum NPCState {
+    STANDING = "standing",
+    TALKING = "talking",
+    FOLLOWPATH = "followPath"
+}
+export declare enum NPCBodyType {
+    MALE = "BaseMale",
+    FEMALE = "BaseFemale"
+}
+export declare enum NPCType {
+    BLANK = "blank",
+    CUSTOM = "custom",
+    AVATAR = "avatar"
+}
+export declare enum NPCPathType {
+    SMOOTH_PATH = "smooth",
+    RIGID_PATH = "rigid"
+}