added crane interialtion with other assets

app/src/modules/simulation/human/eventManager/useHumanEventManager.ts

@@ -25,7 +25,7 @@ export function useHumanEventManager() {
     const addHumanToMonitor = (humanId: string, callback: () => void, actionUuid: string) => {
         const human = getHumanById(humanId);
         const action = getActionByUuid(selectedProduct.productUuid, actionUuid);
-        if (!human || !action || (action.actionType !== 'assembly' && action.actionType !== 'worker') || !humanEventManagerRef.current) return;
+        if (!human || !action || (action.actionType !== 'assembly' && action.actionType !== 'worker' && action.actionType !== 'operator') || !humanEventManagerRef.current) return;
 
         let state = humanEventManagerRef.current.humanStates.find(h => h.humanId === humanId);
         if (!state) {
@@ -36,7 +36,7 @@ export function useHumanEventManager() {
         const existingAction = state.actionQueue.find(a => a.actionUuid === actionUuid);
         if (existingAction) {
             const currentCount = existingAction.count ?? 0;
-            if (existingAction.actionType === 'worker') {
+            if (existingAction.actionType === 'worker' || existingAction.actionType === 'operator') {
                 if (currentCount < existingAction.maxLoadCount) {
                     existingAction.callback = callback;
                     existingAction.isMonitored = true;
@@ -98,8 +98,8 @@ export function useHumanEventManager() {
 
             let conditionMet = false;
 
-            if (currentAction.actionType === 'worker') {
-                if (action.actionType === 'worker' && human.currentLoad < currentAction.loadCapacity) {
+            if (currentAction.actionType === 'worker' || currentAction.actionType === 'operator') {
+                if ((action.actionType === 'worker' || action.actionType === 'operator') && human.currentLoad < currentAction.loadCapacity) {
                     conditionMet = true;
                 } else if (action.actionType === 'assembly') {
                     conditionMet = true;
@@ -107,7 +107,7 @@ export function useHumanEventManager() {
             } else if (currentAction.actionType === 'assembly') {
                 if (action.actionType === 'assembly') {
                     conditionMet = true;
-                } else if (action.actionType === 'worker' && human.currentLoad < currentAction.loadCapacity) {
+                } else if ((action.actionType === 'worker' || action.actionType === 'operator') && human.currentLoad < currentAction.loadCapacity) {
                     conditionMet = true;
                 }
             }
@@ -121,7 +121,7 @@ export function useHumanEventManager() {
                 action.callback();
                 action.count = (action.count ?? 0) + 1;
                 action.isMonitored = false;
-                if ((action.actionType === 'worker' && action.count >= action.maxLoadCount) ||
+                if (((action.actionType === 'worker' || action.actionType === 'operator') && action.count >= action.maxLoadCount) ||
                     (action.actionType === 'assembly' && action.count >= action.maxAssemblyCount)) {
                     action.isCompleted = true;
                 }

app/src/modules/simulation/human/instances/animator/operatorAnimator.tsx

@@ -0,0 +1,182 @@
+import { useEffect, useRef, useState } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import * as THREE from 'three';
+import { Line } from '@react-three/drei';
+import { useAnimationPlaySpeed, usePauseButtonStore, usePlayButtonStore, useResetButtonStore } from '../../../../../store/usePlayButtonStore';
+import { useSceneContext } from '../../../../scene/sceneContext';
+import { useProductContext } from '../../../products/productContext';
+
+interface WorkerAnimatorProps {
+    path: [number, number, number][];
+    handleCallBack: () => void;
+    reset: () => void;
+    human: HumanStatus;
+}
+
+function OperatorAnimator({ path, handleCallBack, human, reset }: Readonly<WorkerAnimatorProps>) {
+    const { humanStore, assetStore, productStore } = useSceneContext();
+    const { getActionByUuid } = productStore();
+    const { selectedProductStore } = useProductContext();
+    const { selectedProduct } = selectedProductStore();
+    const { getHumanById } = humanStore();
+    const { setCurrentAnimation } = assetStore();
+    const { isPaused } = usePauseButtonStore();
+    const { isPlaying } = usePlayButtonStore();
+    const { speed } = useAnimationPlaySpeed();
+    const { isReset, setReset } = useResetButtonStore();
+    const progressRef = useRef<number>(0);
+    const movingForward = useRef<boolean>(true);
+    const completedRef = useRef<boolean>(false);
+    const action = getActionByUuid(selectedProduct.productUuid, human?.currentAction?.actionUuid || '');
+    const [objectRotation, setObjectRotation] = useState<[number, number, number] | null>((action as HumanAction)?.pickUpPoint?.rotation || [0, 0, 0]);
+    const [restRotation, setRestingRotation] = useState<boolean>(true);
+    const [currentPath, setCurrentPath] = useState<[number, number, number][]>([]);
+    const { scene } = useThree();
+
+    useEffect(() => {
+        if (!human.currentAction?.actionUuid) return;
+        const action = getActionByUuid(selectedProduct.productUuid, human?.currentAction?.actionUuid || '');
+        if (human.currentPhase === 'init-loadPoint' && path.length > 0) {
+            setCurrentPath(path);
+            setObjectRotation((action as HumanAction).pickUpPoint?.rotation ?? null);
+        } else if (human.currentPhase === 'loadPoint-unloadPoint' && path.length > 0) {
+            setObjectRotation((action as HumanAction)?.dropPoint?.rotation ?? null);
+            setCurrentPath(path);
+        } else if (human.currentPhase === 'unloadPoint-loadPoint' && path.length > 0) {
+            setObjectRotation((action as HumanAction)?.pickUpPoint?.rotation ?? null);
+            setCurrentPath(path);
+        }
+    }, [human.currentPhase, path, objectRotation, selectedProduct, human.currentAction?.actionUuid]);
+
+    useEffect(() => {
+        completedRef.current = false;
+    }, [currentPath]);
+
+    useEffect(() => {
+        if (isReset || !isPlaying) {
+            reset();
+            setCurrentPath([]);
+            completedRef.current = false;
+            movingForward.current = true;
+            progressRef.current = 0;
+            setReset(false);
+            setRestingRotation(true);
+            const object = scene.getObjectByProperty('uuid', human.modelUuid);
+            const humanData = getHumanById(human.modelUuid);
+            if (object && humanData) {
+                object.position.set(humanData.position[0], humanData.position[1], humanData.position[2]);
+                object.rotation.set(humanData.rotation[0], humanData.rotation[1], humanData.rotation[2]);
+            }
+        }
+    }, [isReset, isPlaying]);
+
+    const lastTimeRef = useRef(performance.now());
+
+    useFrame(() => {
+        const now = performance.now();
+        const delta = (now - lastTimeRef.current) / 1000;
+        lastTimeRef.current = now;
+
+        const object = scene.getObjectByProperty('uuid', human.modelUuid);
+        if (!object || currentPath.length < 2) return;
+        if (isPaused || !isPlaying) return;
+
+        let totalDistance = 0;
+        const distances = [];
+        let accumulatedDistance = 0;
+        let index = 0;
+        const rotationSpeed = 1.5;
+
+        for (let i = 0; i < currentPath.length - 1; i++) {
+            const start = new THREE.Vector3(...currentPath[i]);
+            const end = new THREE.Vector3(...currentPath[i + 1]);
+            const segmentDistance = start.distanceTo(end);
+            distances.push(segmentDistance);
+            totalDistance += segmentDistance;
+        }
+
+        while (index < distances.length && progressRef.current > accumulatedDistance + distances[index]) {
+            accumulatedDistance += distances[index];
+            index++;
+        }
+
+        if (index < distances.length) {
+            const start = new THREE.Vector3(...currentPath[index]);
+            const end = new THREE.Vector3(...currentPath[index + 1]);
+            const segmentDistance = distances[index];
+
+            const targetQuaternion = new THREE.Quaternion().setFromRotationMatrix(
+                new THREE.Matrix4().lookAt(start, end, new THREE.Vector3(0, 1, 0))
+            );
+            const y180 = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+            targetQuaternion.multiply(y180);
+
+            const angle = object.quaternion.angleTo(targetQuaternion);
+            if (angle < 0.01) {
+                object.quaternion.copy(targetQuaternion);
+            } else {
+                const step = rotationSpeed * delta * speed * human.speed;
+                object.quaternion.rotateTowards(targetQuaternion, step);
+            }
+
+            const isAligned = angle < 0.01;
+
+            if (isAligned) {
+                progressRef.current += delta * (speed * human.speed);
+                const t = (progressRef.current - accumulatedDistance) / segmentDistance;
+                const position = start.clone().lerp(end, t);
+                object.position.copy(position);
+                setCurrentAnimation(human.modelUuid, 'walking', true, true, true);
+            } else {
+                setCurrentAnimation(human.modelUuid, 'idle', true, true, true);
+            }
+        }
+
+        if (progressRef.current >= totalDistance) {
+            if (restRotation && objectRotation) {
+                const targetEuler = new THREE.Euler(0, objectRotation[1], 0);
+                const baseQuaternion = new THREE.Quaternion().setFromEuler(targetEuler);
+                const y180 = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+                const targetQuaternion = baseQuaternion.multiply(y180);
+
+                const angle = object.quaternion.angleTo(targetQuaternion);
+                if (angle < 0.01) {
+                    object.quaternion.copy(targetQuaternion);
+                    setRestingRotation(false);
+                } else {
+                    const step = rotationSpeed * delta * speed * human.speed;
+                    object.quaternion.rotateTowards(targetQuaternion, step);
+                }
+
+                setCurrentAnimation(human.modelUuid, 'idle', true, true, true);
+                return;
+            }
+        }
+
+        if (progressRef.current >= totalDistance) {
+            setRestingRotation(true);
+            progressRef.current = 0;
+            movingForward.current = !movingForward.current;
+            setCurrentPath([]);
+            handleCallBack();
+        }
+    });
+
+    return (
+        <>
+            {currentPath.length > 0 && (
+                <group visible={false}>
+                    <Line points={currentPath} color="blue" lineWidth={3} />
+                    {currentPath.map((point, index) => (
+                        <mesh key={index} position={point}>
+                            <sphereGeometry args={[0.1, 16, 16]} />
+                            <meshStandardMaterial color="red" />
+                        </mesh>
+                    ))}
+                </group>
+            )}
+        </>
+    );
+}
+
+export default OperatorAnimator;

app/src/modules/simulation/human/instances/instance/actions/operatorInstance.tsx

@@ -0,0 +1,168 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { useThree } from '@react-three/fiber';
+import { NavMeshQuery } from '@recast-navigation/core';
+import { useNavMesh } from '../../../../../../store/builder/store';
+import { useAnimationPlaySpeed, usePauseButtonStore, usePlayButtonStore } from '../../../../../../store/usePlayButtonStore';
+import { useTriggerHandler } from '../../../../triggers/triggerHandler/useTriggerHandler';
+import { useSceneContext } from '../../../../../scene/sceneContext';
+import { useProductContext } from '../../../../products/productContext';
+
+import OperatorAnimator from '../../animator/operatorAnimator';
+
+function OperatorInstance({ human }: { human: HumanStatus }) {
+    const { navMesh } = useNavMesh();
+    const { isPlaying } = usePlayButtonStore();
+    const { scene } = useThree();
+    const { assetStore, materialStore, armBotStore, conveyorStore, machineStore, vehicleStore, humanStore, storageUnitStore, craneStore, productStore } = useSceneContext();
+    const { removeMaterial, setEndTime, setIsVisible } = materialStore();
+    const { getStorageUnitById } = storageUnitStore();
+    const { getArmBotById } = armBotStore();
+    const { getConveyorById } = conveyorStore();
+    const { getVehicleById } = vehicleStore();
+    const { getMachineById } = machineStore();
+    const { getCraneById } = craneStore();
+    const { triggerPointActions } = useTriggerHandler();
+    const { setCurrentAnimation, resetAnimation, getAssetById } = assetStore();
+    const { getActionByUuid, getEventByModelUuid, getTriggerByUuid } = productStore();
+    const { selectedProductStore } = useProductContext();
+    const { selectedProduct } = selectedProductStore();
+    const { setHumanActive, setHumanState, clearCurrentMaterials, setHumanLoad, setHumanScheduled, decrementHumanLoad, removeLastMaterial, incrementIdleTime, incrementActiveTime, resetTime, setCurrentPhase } = humanStore();
+
+    const [path, setPath] = useState<[number, number, number][]>([]);
+    const pauseTimeRef = useRef<number | null>(null);
+    const idleTimeRef = useRef<number>(0);
+    const activeTimeRef = useRef<number>(0);
+    const isPausedRef = useRef<boolean>(false);
+    const isSpeedRef = useRef<number>(0);
+    const { speed } = useAnimationPlaySpeed();
+    const { isPaused } = usePauseButtonStore();
+    const previousTimeRef = useRef<number | null>(null);
+    const animationFrameIdRef = useRef<number | null>(null);
+    const humanAsset = getAssetById(human.modelUuid);
+
+    useEffect(() => {
+        isPausedRef.current = isPaused;
+    }, [isPaused]);
+
+    useEffect(() => {
+        isSpeedRef.current = speed;
+    }, [speed]);
+
+    const computePath = useCallback((start: [number, number, number], end: [number, number, number]) => {
+        try {
+            const navMeshQuery = new NavMeshQuery(navMesh);
+            let startPoint = new THREE.Vector3(start[0], start[1], start[2]);
+            let endPoint = new THREE.Vector3(end[0], end[1], end[2]);
+            const { path: segmentPath } = navMeshQuery.computePath(startPoint, endPoint);
+            if (
+                segmentPath.length > 0 &&
+                Math.round(segmentPath[segmentPath.length - 1].x) == Math.round(endPoint.x) &&
+                Math.round(segmentPath[segmentPath.length - 1].z) == Math.round(endPoint.z)
+            ) {
+                return segmentPath?.map(({ x, y, z }) => [x, 0, z] as [number, number, number]) || [];
+            } else {
+                console.log("There is no path here...Choose valid path")
+                const { path: segmentPaths } = navMeshQuery.computePath(startPoint, startPoint);
+                return segmentPaths.map(({ x, y, z }) => [x, 0, z] as [number, number, number]) || [];
+            }
+        } catch {
+            console.error("Failed to compute path");
+            return [];
+        }
+    }, [navMesh]);
+
+    function humanStatus(modelId: string, status: string) {
+        // console.log(`${modelId} , ${status}`);
+    }
+
+    function reset() {
+        setCurrentPhase(human.modelUuid, 'init');
+        setHumanActive(human.modelUuid, false);
+        setHumanState(human.modelUuid, 'idle');
+        setHumanScheduled(human.modelUuid, false);
+        setHumanLoad(human.modelUuid, 0);
+        resetAnimation(human.modelUuid);
+        setPath([]);
+        isPausedRef.current = false;
+        pauseTimeRef.current = 0;
+        resetTime(human.modelUuid)
+        activeTimeRef.current = 0
+        idleTimeRef.current = 0
+        previousTimeRef.current = null
+        if (animationFrameIdRef.current !== null) {
+            cancelAnimationFrame(animationFrameIdRef.current)
+            animationFrameIdRef.current = null
+        }
+        const object = scene.getObjectByProperty('uuid', human.modelUuid);
+        if (object && human) {
+            object.position.set(human.position[0], human.position[1], human.position[2]);
+            object.rotation.set(human.rotation[0], human.rotation[1], human.rotation[2]);
+        }
+    }
+
+    useEffect(() => {
+        if (isPlaying) {
+            const action = getActionByUuid(selectedProduct.productUuid, human?.currentAction?.actionUuid || '');
+            if (!action || action.actionType !== 'operator' || !action.pickUpPoint || !action.dropPoint) return;
+
+            if (!human.isActive && human.state === 'idle' && human.currentPhase === 'init') {
+                const humanMesh = scene.getObjectByProperty('uuid', human.modelUuid);
+                if (!humanMesh) return;
+
+                const toPickupPath = computePath(humanMesh.position.toArray(), action?.pickUpPoint?.position || [0, 0, 0]);
+
+                setPath(toPickupPath);
+                setCurrentPhase(human.modelUuid, 'init-loadPoint');
+                setHumanState(human.modelUuid, 'running');
+                setHumanActive(human.modelUuid, true);
+                setCurrentAnimation(human.modelUuid, 'walking', true, true, true);
+                humanStatus(human.modelUuid, 'Started from init, heading to loadPoint');
+            } else if (human.isActive && human.currentPhase === 'loadPoint-unloadPoint') {
+                if (action.pickUpPoint && action.dropPoint && humanAsset?.animationState?.current === 'idle') {
+                    const toDrop = computePath(action.pickUpPoint.position || [0, 0, 0], action.dropPoint.position || [0, 0, 0]);
+                    setPath(toDrop);
+                    setCurrentAnimation(human.modelUuid, 'walking', true, true, true);
+                    humanStatus(human.modelUuid, 'Started from loadPoint, heading to unloadPoint');
+                }
+            } else if (human.state === 'idle' && human.currentPhase === 'unhooking') {
+                setHumanState(human.modelUuid, 'running');
+                setHumanActive(human.modelUuid, true);
+                setCurrentAnimation(human.modelUuid, 'working_standing', true, false, false);
+            }
+        } else {
+            reset()
+        }
+    }, [human, human.currentAction, human.currentPhase, path, isPlaying, humanAsset?.animationState?.isCompleted]);
+
+    function handleCallBack() {
+        if (human.currentPhase === 'init-loadPoint') {
+            setCurrentPhase(human.modelUuid, 'waiting');
+            setHumanState(human.modelUuid, 'idle');
+            setHumanActive(human.modelUuid, false);
+            setCurrentAnimation(human.modelUuid, 'idle', true, true, true);
+            humanStatus(human.modelUuid, 'Reached loadPoint point, waiting for material');
+            setPath([]);
+        } else if (human.currentPhase === 'loadPoint-unloadPoint') {
+            setCurrentPhase(human.modelUuid, 'unhooking');
+            setHumanState(human.modelUuid, 'idle');
+            setHumanActive(human.modelUuid, false);
+            setCurrentAnimation(human.modelUuid, 'idle', true, true, true);
+            humanStatus(human.modelUuid, 'Reached loadPoint point, waiting for material');
+            setPath([]);
+        }
+    }
+
+    return (
+        <>
+            <OperatorAnimator
+                path={path}
+                handleCallBack={handleCallBack}
+                human={human}
+                reset={reset}
+            />
+        </>
+    )
+}
+
+export default OperatorInstance;

app/src/modules/simulation/human/instances/instance/humanInstance.tsx

@@ -6,6 +6,7 @@ import { useProductContext } from '../../../products/productContext';
 import MaterialAnimator from '../animator/materialAnimator';
 import AssemblerInstance from './actions/assemberInstance';
 import WorkerInstance from './actions/workerInstance';
+import OperatorInstance from './actions/operatorInstance';
 
 function HumanInstance({ human }: { human: HumanStatus }) {
     const { isPlaying } = usePlayButtonStore();
@@ -86,6 +87,9 @@ function HumanInstance({ human }: { human: HumanStatus }) {
             {action && action.actionType === 'assembly' &&
                 <AssemblerInstance human={human} />
             }
+            {action && action.actionType === 'operator' &&
+                <OperatorInstance human={human} />
+            }
 
             <MaterialAnimator human={human} />
         </>