Merge remote-tracking branch 'origin/simulation' into simulation-animation

app/src/modules/simulation/process/processAnimator.tsx

@@ -1,4 +1,4 @@
-import React, { useRef, useEffect, useMemo } from "react";
+import React, { useRef, useEffect, useMemo, useCallback } from "react";
 import { useLoader, useFrame } from "@react-three/fiber";
 import { GLTFLoader } from "three-stdlib";
 import * as THREE from "three";
@@ -10,11 +10,27 @@ import ProcessObject from "./processObject";
 import { ProcessData } from "./types";
 
 
+interface ArmBotState {
+  uuid: string;
+  position: [number, number, number];
+  rotation: [number, number, number];
+  status: string;
+  material: string;
+  triggerId: string;
+  connections: {
+    source: { modelUUID: string; pointUUID: string };
+    targets: { modelUUID: string; pointUUID: string }[];
+  };
+  actions: { uuid: string; name: string; speed: number; processes: { triggerId: string; startPoint: string; endPoint: string }[]; };
+  isActive?: boolean;
+}
 interface ProcessContainerProps {
   processes: ProcessData[];
   setProcesses: React.Dispatch<React.SetStateAction<any[]>>;
   agvRef: any;
   MaterialRef: any;
+  armBots: ArmBotState[];
+  setArmBots: React.Dispatch<React.SetStateAction<ArmBotState[]>>;
 }
 
 const ProcessAnimator: React.FC<ProcessContainerProps> = ({
@@ -22,6 +38,8 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
   setProcesses,
   agvRef,
   MaterialRef,
+  armBots,
+  setArmBots
 }) => {
   const gltf = useLoader(GLTFLoader, crate) as GLTF;
   const groupRef = useRef<THREE.Group>(null);
@@ -41,7 +59,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
     getPointDataForAnimationIndex,
     processes: processedProcesses,
     checkAndCountTriggers,
-  } = useProcessAnimation(processes, setProcesses, agvRef);
+  } = useProcessAnimation(processes, setProcesses, agvRef, armBots, setArmBots);
 
   const baseMaterials = useMemo(
     () => ({
@@ -96,6 +114,29 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
 
   // In processAnimator.tsx - only the relevant spawn logic part that needs fixes
 
+
+  // Add this function to ProcessAnimator component
+  const isConnectedToActiveArmBot = useCallback(
+    (processId: any) => {
+      // Check if any active armbot is connected to this process
+      return armBots.some((armbot) => {
+        if (!armbot.isActive) return false;
+
+        // Check if this armbot is connected to the process
+        return armbot.connections?.targets?.some((connection: any) => {
+          // Find the process that owns this modelUUID
+          const connectedProcess = processes.find((p) =>
+            p.paths?.some((path) => path.modeluuid === connection.modelUUID)
+          );
+          return connectedProcess?.id === processId;
+        });
+      });
+    },
+    [armBots, processes]
+  );
+
+  // In processAnimator.tsx - only the relevant spawn logic part that needs fixes
+
   useFrame(() => {
     // Spawn logic frame
     const currentTime =
@@ -113,6 +154,14 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
           return;
         }
 
+        if (isConnectedToActiveArmBot(process.id)) {
+          newStates[process.id] = {
+            ...processState,
+            nextSpawnTime: Infinity, // Prevent future spawns
+          };
+          return;
+        }
+
         const spawnPoint = findSpawnPoint(process);
         if (!spawnPoint || !spawnPoint.actions) return;
 
@@ -180,6 +229,29 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
         const processState = newStates[process.id];
         if (!processState) return;
 
+        if (isConnectedToActiveArmBot(process.id)) {
+          newStates[process.id] = {
+            ...processState,
+            spawnedObjects: Object.entries(processState.spawnedObjects).reduce(
+              (acc, [id, obj]) => ({
+                ...acc,
+                [id]: {
+                  ...obj,
+                  state: {
+                    ...obj.state,
+                    isAnimating: false, // Stop animation
+                    isDelaying: false, // Clear delays
+                    delayComplete: false, // Reset delays
+                    progress: 0, // Reset progress
+                  },
+                },
+              }),
+              {}
+            ),
+          };
+          return;
+        }
+
         if (processState.isProcessDelaying) {
           const effectiveDelayTime =
             processState.processDelayDuration / speedRef.current;
@@ -444,7 +516,6 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
       return newStates;
     });
   });
-
   if (!processedProcesses || processedProcesses.length === 0) {
     return null;
   }