added machine actions

app/src/components/ui/simulation/simulationPlayer.tsx

@@ -38,10 +38,18 @@ const SimulationPlayer: React.FC = () => {
   const { isReset, setReset } = useResetButtonStore();
   const { subModule } = useSubModuleStore();
 
+  useEffect(() => {
+    if (isReset) {
+      setTimeout(() => {
+        setReset(false);
+      }, 0)
+    }
+  }, [isReset])
+
   // Button functions
   const handleReset = () => {
-    setReset(!isReset);
+    setReset(true);
-    setSpeed(1);
+    // setSpeed(1);
   };
   const handlePlayStop = () => {
     setIsPaused(!isPaused);
@@ -271,8 +279,7 @@ const SimulationPlayer: React.FC = () => {
                         </div>
                         {index < intervals.length - 1 && (
                           <div
-                            className={`line ${
+                            className={`line ${progress >= ((index + 1) / totalSegments) * 100
-                              progress >= ((index + 1) / totalSegments) * 100
                               ? "filled"
                               : ""
                               }`}
@@ -314,8 +321,7 @@ const SimulationPlayer: React.FC = () => {
                 <div className="custom-slider-wrapper">
                   <div className="custom-slider">
                     <button
-                      className={`slider-handle ${
+                      className={`slider-handle ${isDragging ? "dragging" : ""
-                        isDragging ? "dragging" : ""
                         }`}
                       style={{ left: `${calculateHandlePosition()}%` }}
                       onMouseDown={handleMouseDown}

app/src/modules/simulation/actions/useActionHandler.ts

@@ -6,20 +6,20 @@ import { useVehicleActions } from "./vehicle/useVehicleActions";
 
 // Master hook that selects the appropriate action handler
 export function useActionHandler(point: PointsScheme) {
-    if ('actions' in point) {
+    // if ('actions' in point) {
-        // Robotic Arm
+    //     // Robotic Arm
-        useRoboticArmActions(point);
+    //     useRoboticArmActions(point);
-    } else if (point.action.actionType === 'travel') {
+    // } else if (point.action.actionType === 'travel') {
-        // Vehicle
+    //     // Vehicle
-        useVehicleActions(point as VehiclePointSchema);
+    //     useVehicleActions(point as VehiclePointSchema);
-    } else if (point.action.actionType === 'process') {
+    // } else if (point.action.actionType === 'process') {
-        // Machine
+    //     // Machine
-        useMachineActions(point as MachinePointSchema);
+    //     useMachineActions(point as MachinePointSchema);
-    } else if (point.action.actionType === 'store') {
+    // } else if (point.action.actionType === 'store') {
-        // Storage
+    //     // Storage
-        useStorageActions(point as StoragePointSchema);
+    //     useStorageActions(point as StoragePointSchema);
-    } else {
+    // } else {
-        // Conveyor
+    //     // Conveyor
-        useConveyorActions(point as ConveyorPointSchema);
+    //     useConveyorActions(point as ConveyorPointSchema);
-    }
+    // }
 }

app/src/modules/simulation/machine/instances/animator/machineAnimator.tsx

@@ -34,16 +34,12 @@ const MachineAnimator = ({ currentPhase, handleCallBack, processingTime, machine
     useEffect(() => {
         isPlayingRef.current = isPlaying;
     }, [isPlaying]);
-    useEffect(() => {
+
-        isResetRef.current = isReset;
-    }, [isReset]);
 
 
     useEffect(() => {
-
         if (isReset || !isPlaying) {
             reset();
-            setReset(false);
             startTimeRef.current = 0;
             isPausedRef.current = false;
             pauseTimeRef.current = 0;
@@ -53,20 +49,19 @@ const MachineAnimator = ({ currentPhase, handleCallBack, processingTime, machine
         }
     }, [isReset, isPlaying])
 
+
+
     useEffect(() => {
         if (currentPhase === 'processing' && !animationStarted.current && machineUuid) {
             animationStarted.current = true;
             startTimeRef.current = performance.now();
             animationFrameId.current = requestAnimationFrame(step);
         }
+
     }, [currentPhase]);
 
     function step(time: number) {
-        if (!isPausedRef.current || !isResetRef.current) {
+
-            if (animationFrameId.current) {
-                cancelAnimationFrame(animationFrameId.current);
-                animationFrameId.current = null;
-            }
         if (isPausedRef.current) {
             if (!pauseTimeRef.current) {
                 pauseTimeRef.current = performance.now();
@@ -82,18 +77,23 @@ const MachineAnimator = ({ currentPhase, handleCallBack, processingTime, machine
         }
 
         const elapsed = time - startTimeRef.current;
-            const processedTime = processingTime * 1000;
+        const processedTime = (processingTime * 1000) / speed;
+
         if (elapsed < processedTime) {
             machineStatus(machineUuid, "Machine is currently processing the task");
             animationFrameId.current = requestAnimationFrame(step);
         } else {
-                removeCurrentAction(machineUuid);
             animationStarted.current = false;
+            if (animationFrameId.current !== null) {
+                removeCurrentAction(machineUuid);
+                cancelAnimationFrame(animationFrameId.current);
+                animationFrameId.current = null;
                 handleCallBack();
+            }
 
         }
     }
-    }
+
 
 
     return null;

app/src/modules/simulation/machine/instances/machineInstance/machineInstance.tsx

@@ -10,10 +10,10 @@ function MachineInstance({ machineDetail }: any) {
     const { machines, addCurrentAction, setMachineState, setMachineActive } = useMachineStore();
 
     const reset = () => {
+        setCurrentPhase("idle");
         setMachineState(machineDetail.modelUuid, 'idle');
         setMachineActive(machineDetail.modelUuid, false);
         isIncrememtable.current = true;
-        setCurrentPhase("idle");
     }
     const increment = () => {
         if (isIncrememtable.current) {
@@ -31,7 +31,7 @@ function MachineInstance({ machineDetail }: any) {
             if (!machineDetail.isActive && machineDetail.state === "idle" && currentPhase == "idle" && !machineDetail.currentAction) {
                 setTimeout(() => {
                     increment();
-                }, 2000);
+                }, 5000);
                 machineStatus(machineDetail.modelUuid, 'Machine is idle and waiting for next instruction.')
             } else if (!machineDetail.isActive && machineDetail.state === "idle" && currentPhase == "idle" && machineDetail.currentAction) {
                 setCurrentPhase("processing");
@@ -39,8 +39,6 @@ function MachineInstance({ machineDetail }: any) {
                 setMachineActive(machineDetail.modelUuid, true);
                 machineStatus(machineDetail.modelUuid, "Machine started processing")
             }
-        } else {
-            reset();
         }
     }, [currentPhase, isPlaying, machines])
 

app/src/modules/simulation/simulator/simulator.tsx

@@ -7,7 +7,7 @@ function Simulator() {
     const executionOrder = determineExecutionOrder(products);
 
     executionOrder.forEach(point => {
-        useActionHandler(point);
+        // useActionHandler(point);
     });
 
     function determineExecutionSequences(products: productsSchema): PointsScheme[][] {