Debugged agv and conveyor interaction.

app/package-lock.json

@@ -2020,7 +2020,7 @@
       "version": "0.8.1",
       "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
       "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
-      "dev": true,
+      "devOptional": true,
       "dependencies": {
         "@jridgewell/trace-mapping": "0.3.9"
       },
@@ -2032,7 +2032,7 @@
       "version": "0.3.9",
       "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
       "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
-      "dev": true,
+      "devOptional": true,
       "dependencies": {
         "@jridgewell/resolve-uri": "^3.0.3",
         "@jridgewell/sourcemap-codec": "^1.4.10"
@@ -4135,6 +4135,26 @@
         "url": "https://github.com/sponsors/gregberge"
       }
     },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.0.tgz",
+      "integrity": "sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "chalk": "^4.1.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@testing-library/jest-dom": {
       "version": "5.17.0",
       "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-5.17.0.tgz",
@@ -4246,25 +4266,25 @@
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz",
       "integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/@tsconfig/node12": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
       "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/@tsconfig/node14": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
       "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/@tsconfig/node16": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
       "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/@turf/along": {
       "version": "7.2.0",
@@ -9007,7 +9027,7 @@
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
       "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/cross-env": {
       "version": "7.0.3",
@@ -9884,7 +9904,7 @@
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
       "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
-      "dev": true,
+      "devOptional": true,
       "engines": {
         "node": ">=0.3.1"
       }
@@ -15247,7 +15267,7 @@
       "version": "1.3.6",
       "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
       "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/makeerror": {
       "version": "1.0.12",
@@ -20715,7 +20735,7 @@
       "version": "10.9.2",
       "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
-      "dev": true,
+      "devOptional": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -20758,7 +20778,7 @@
       "version": "8.3.4",
       "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
       "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
-      "dev": true,
+      "devOptional": true,
       "dependencies": {
         "acorn": "^8.11.0"
       },
@@ -20770,7 +20790,7 @@
       "version": "4.1.3",
       "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
       "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/tsconfig-paths": {
       "version": "3.15.0",
@@ -21266,7 +21286,7 @@
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
       "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
-      "dev": true
+      "devOptional": true
     },
     "node_modules/v8-to-istanbul": {
       "version": "8.1.1",
@@ -22325,7 +22345,7 @@
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
       "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
-      "dev": true,
+      "devOptional": true,
       "engines": {
         "node": ">=6"
       }

app/src/components/layout/sidebarRight/properties/GlobalProperties.tsx

@@ -98,7 +98,7 @@ const GlobalProperties: React.FC = () => {
     // setPlaneValue({ height: value * 100, width: value * 100 });
   }
   function updatedGrid(value: number) {
-    console.log(" (value * 100) / 4 : ", (value * 100) / 4);
+    // console.log(" (value * 100) / 4 : ", (value * 100) / 4);
     setGridValue({ size: value * 100, divisions: (value * 100) / 4 });
     setPlaneValue({ height: value * 100, width: value * 100 });
   }

app/src/components/layout/sidebarRight/properties/ZoneProperties.tsx

@@ -32,7 +32,7 @@ const ZoneProperties: React.FC = () => {
       if (response.message === "updated successfully") {
         setEdit(false);
       } else {
-        console.log(response);
+        // console.log(response);
       }
 
     } catch (error) {
@@ -63,7 +63,7 @@ const ZoneProperties: React.FC = () => {
         )
       );
     }else{
-      console.log(response?.message);
+      // console.log(response?.message);
     }
   }
   function handleVectorChange(key: "zoneViewPortTarget" | "zoneViewPortPosition", newValue: [number, number, number]) {

app/src/components/ui/componets/RealTimeVisulization.tsx

@@ -85,7 +85,7 @@ const RealTimeVisulization: React.FC = () => {
       const organization = email?.split("@")[1]?.split(".")[0];
       try {
         const response = await getZone2dData(organization);
-        console.log('response: ', response);
+        // console.log('response: ', response);
 
         if (!Array.isArray(response)) {
           return;

app/src/components/ui/realTimeVis/floating/FleetEfficiencyComponent.tsx

@@ -41,7 +41,7 @@ const FleetEfficiencyComponent = ({object}: any) => {
     
         socket.on("lastOutput", (response) => {
           const responseData = response.input1;
-          console.log(responseData);
+          // console.log(responseData);
           
           if (typeof responseData === "number") {
             console.log("It's a number!");

app/src/modules/builder/agv/agv.tsx

@@ -1,111 +1,103 @@
 import { useEffect, useState } from "react";
 import { Line } from "@react-three/drei";
 import {
-  useNavMesh,
+	useNavMesh,
-  usePlayAgv,
+	usePlayAgv,
-  useSimulationStates,
+	useSimulationStates,
 } from "../../../store/store";
 import PathNavigator from "./pathNavigator";
-import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
+import { usePlayButtonStore, useResetButtonStore } from "../../../store/usePlayButtonStore";
 
 type PathPoints = {
-  modelUuid: string;
+	modelUuid: string;
-  modelSpeed: number;
+	modelSpeed: number;
-  bufferTime: number;
+	bufferTime: number;
-  points: { x: number; y: number; z: number }[];
+	points: { x: number; y: number; z: number }[];
-  hitCount: number;
+	hitCount: number;
 };
 interface ProcessContainerProps {
-  processes: any[];
+	processes: any[];
-  agvRef: any;
+	agvRef: any;
-  MaterialRef: any;
+	MaterialRef: any;
 }
 
 const Agv: React.FC<ProcessContainerProps> = ({
-  processes,
+	processes,
-  agvRef,
+	agvRef,
-  MaterialRef,
+	MaterialRef,
 }) => {
-  const [pathPoints, setPathPoints] = useState<PathPoints[]>([]);
+	const [pathPoints, setPathPoints] = useState<PathPoints[]>([]);
-  const { simulationStates } = useSimulationStates();
+	const { simulationStates } = useSimulationStates();
-  const { navMesh } = useNavMesh();
+	const { navMesh } = useNavMesh();
-  const { isPlaying } = usePlayButtonStore();
+	const { isPlaying } = usePlayButtonStore();
-  const { PlayAgv, setPlayAgv } = usePlayAgv();
+	const { isReset, setReset } = useResetButtonStore();
 
+	useEffect(() => {
+		if (!isPlaying || isReset) {
+			agvRef.current = [];
+		}
+	}, [isPlaying, isReset])
 
+	useEffect(() => {
+		if (simulationStates.length > 0) {
+			const agvModels = simulationStates.filter(
+				(val) => val.modelName === "agv" && val.type === "Vehicle"
+			);
 
-  useEffect(() => {
+			const newPathPoints = agvModels
-    if (simulationStates.length > 0) {
+				.filter(
-      const agvModels = simulationStates.filter(
+					(model: any) =>
-        (val) => val.modelName === "agv" && val.type === "Vehicle"
+						model.points &&
-      );
+						model.points.actions &&
+						typeof model.points.actions.start === "object" &&
+						typeof model.points.actions.end === "object" &&
+						"x" in model.points.actions.start &&
+						"y" in model.points.actions.start &&
+						"x" in model.points.actions.end &&
+						"y" in model.points.actions.end
+				)
+				.map((model: any) => ({
+					modelUuid: model.modeluuid,
+					modelSpeed: model.points.speed,
+					bufferTime: model.points.actions.buffer,
+					hitCount: model.points.actions.hitCount,
+					points: [
+						{ x: model.position[0], y: model.position[1], z: model.position[2], },
+						{ x: model.points.actions.start.x, y: 0, z: model.points.actions.start.y, },
+						{ x: model.points.actions.end.x, y: 0, z: model.points.actions.end.y, },
+					],
+				}));
 
-      const newPathPoints = agvModels
+			setPathPoints(newPathPoints);
-        .filter(
+		}
-          (model: any) =>
+	}, [simulationStates]);
-            model.points &&
-            model.points.actions &&
-            typeof model.points.actions.start === "object" &&
-            typeof model.points.actions.end === "object" &&
-            "x" in model.points.actions.start &&
-            "y" in model.points.actions.start &&
-            "x" in model.points.actions.end &&
-            "y" in model.points.actions.end
-        )
-        .map((model: any) => ({
-          modelUuid: model.modeluuid,
-          modelSpeed: model.points.speed,
-          bufferTime: model.points.actions.buffer,
-          hitCount: model.points.actions.hitCount,
-          points: [
-            {
-              x: model.position[0],
-              y: model.position[1],
-              z: model.position[2],
-            },
-            {
-              x: model.points.actions.start.x,
-              y: 0,
-              z: model.points.actions.start.y,
-            },
-            {
-              x: model.points.actions.end.x,
-              y: 0,
-              z: model.points.actions.end.y,
-            },
-          ],
-        }));
 
-      setPathPoints(newPathPoints);
+	return (
-    }
+		<>
-  }, [simulationStates]);
+			{pathPoints.map((pair, i) => (
+				<group key={i} visible={!isPlaying}>
+					<PathNavigator
+						navMesh={navMesh}
+						pathPoints={pair.points}
+						id={pair.modelUuid}
+						speed={pair.modelSpeed}
+						bufferTime={pair.bufferTime}
+						hitCount={pair.hitCount}
+						processes={processes}
+						agvRef={agvRef}
+						MaterialRef={MaterialRef}
+					/>
 
-  return (
+					{pair.points.slice(1).map((point, idx) => (
-    <>
+						<mesh position={[point.x, point.y, point.z]} key={idx}>
-      {pathPoints.map((pair, i) => (
+							<sphereGeometry args={[0.3, 15, 15]} />
-        <group key={i} visible={!isPlaying}>
+							<meshStandardMaterial color="red" />
-          <PathNavigator
+						</mesh>
-            navMesh={navMesh}
+					))}
-            pathPoints={pair.points}
+				</group>
-            id={pair.modelUuid}
+			))}
-            speed={pair.modelSpeed}
+		</>
-            bufferTime={pair.bufferTime}
+	);
-            hitCount={pair.hitCount}
-            processes={processes}
-            agvRef={agvRef}
-            MaterialRef={MaterialRef}
-          />
-
-          {pair.points.slice(1).map((point, idx) => (
-            <mesh position={[point.x, point.y, point.z]} key={idx}>
-              <sphereGeometry args={[0.3, 15, 15]} />
-              <meshStandardMaterial color="red" />
-            </mesh>
-          ))}
-        </group>
-      ))}
-    </>
-  );
 };
 
 export default Agv;

app/src/modules/builder/agv/pathNavigator.tsx

@@ -5,7 +5,6 @@ import { NavMeshQuery } from "@recast-navigation/core";
 import { Line } from "@react-three/drei";
 import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
 import { usePlayAgv } from "../../../store/store";
-import crate from "../../../assets/gltf-glb/crate_box.glb";
 
 interface PathNavigatorProps {
   navMesh: any;
@@ -38,30 +37,12 @@ export default function PathNavigator({
   MaterialRef,
 }: PathNavigatorProps) {
   const [currentPhase, setCurrentPhase] = useState<Phase>("initial");
-  //
-
   const [path, setPath] = useState<[number, number, number][]>([]);
-  const PickUpDrop = useRef([]);
+  const [toPickupPath, setToPickupPath] = useState<[number, number, number][]>([]);
-
+  const [pickupDropPath, setPickupDropPath] = useState<[number, number, number][]>([]);
-  // const [currentPhase, setCurrentPhase] = useState<"initial" | "loop">(
+  const [dropPickupPath, setDropPickupPath] = useState<[number, number, number][]>([]);
-  //   "initial"
+  const [initialPosition, setInitialPosition] = useState<THREE.Vector3 | null>(null);
-  // );
+  const [initialRotation, setInitialRotation] = useState<THREE.Euler | null>(null);
-  const [toPickupPath, setToPickupPath] = useState<[number, number, number][]>(
-    []
-  );
-
-  const [pickupDropPath, setPickupDropPath] = useState<
-    [number, number, number][]
-  >([]);
-  const [dropPickupPath, setDropPickupPath] = useState<
-    [number, number, number][]
-  >([]);
-  const [initialPosition, setInitialPosition] = useState<THREE.Vector3 | null>(
-    null
-  );
-  const [initialRotation, setInitialRotation] = useState<THREE.Euler | null>(
-    null
-  );
   const [boxVisible, setBoxVisible] = useState(false);
 
   const distancesRef = useRef<number[]>([]);
@@ -70,11 +51,20 @@ export default function PathNavigator({
   const isWaiting = useRef(false);
   const timeoutRef = useRef<NodeJS.Timeout | null>(null);
   const hasStarted = useRef(false);
+  const hasReachedPickup = useRef(false);
 
   const { scene } = useThree();
   const { isPlaying } = usePlayButtonStore();
   const { PlayAgv, setPlayAgv } = usePlayAgv();
 
+  const boxRef = useRef<THREE.Mesh | null>(null);
+
+  const baseMaterials = useMemo(() => ({
+    Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
+    Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
+    Default: new THREE.MeshStandardMaterial({ color: 0xcccccc })
+  }), []);
+
   useEffect(() => {
     const object = scene.getObjectByProperty("uuid", id);
     if (object) {
@@ -105,12 +95,16 @@ export default function PathNavigator({
 
     setPath([]);
     setCurrentPhase("initial");
+    setToPickupPath([]);
     setPickupDropPath([]);
     setDropPickupPath([]);
+    setBoxVisible(false);
     distancesRef.current = [];
     totalDistanceRef.current = 0;
     progressRef.current = 0;
     isWaiting.current = false;
+    hasStarted.current = false;
+    hasReachedPickup.current = false;
 
     if (initialPosition && initialRotation) {
       const object = scene.getObjectByProperty("uuid", id);
@@ -130,27 +124,16 @@ export default function PathNavigator({
 
     const [pickup, drop] = pathPoints.slice(-2);
 
-    PickUpDrop.current = pathPoints.slice(-2);
-
     const object = scene.getObjectByProperty("uuid", id);
-
     if (!object) return;
 
-    const currentPosition = {
+    const currentPosition = object.position;
-      x: object.position.x,
-      y: object.position.y,
-      z: object.position.z,
-    };
 
     const toPickupPath = computePath(currentPosition, pickup);
     const pickupToDropPath = computePath(pickup, drop);
     const dropToPickupPath = computePath(drop, pickup);
 
-    if (
+    if (toPickupPath.length && pickupToDropPath.length && dropToPickupPath.length) {
-      toPickupPath.length &&
-      pickupToDropPath.length &&
-      dropToPickupPath.length
-    ) {
       setPickupDropPath(pickupToDropPath);
       setDropPickupPath(dropToPickupPath);
       setToPickupPath(toPickupPath);
@@ -177,25 +160,9 @@ export default function PathNavigator({
     isWaiting.current = false;
   }, [path]);
 
-  // Add these refs outside the useFrame if not already present:
+  function logAgvStatus(id: string, status: string) {
-  const startPointReached = useRef(false);
+    // console.log(`AGV ${id}: ${status}`);
-
+  }
-  const baseMaterials = useMemo(
-    () => ({
-      Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
-      Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
-      // Default: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
-      Default: new THREE.MeshStandardMaterial(),
-    }),
-    []
-  );
-
-  // Example usage:
-  const targetModelUUID = id; // Replace with your target ID
-  const matchedProcess = findProcessByTargetModelUUID(
-    processes,
-    targetModelUUID
-  );
 
   function findProcessByTargetModelUUID(processes: any, targetModelUUID: any) {
     for (const process of processes) {
@@ -206,75 +173,55 @@ export default function PathNavigator({
               (target: any) => target.modelUUID === targetModelUUID
             )
           ) {
-            //
+            return process.id;
-            return process.id; // Return the process if a match is found
           }
         }
       }
     }
-    return null; // Return null if no match is found
+    return null;
   }
 
-  useFrame((_, delta) => {});
-  const boxRef = useRef<THREE.Mesh | null>(null);
-
   useEffect(() => {
-    if (!scene || !boxRef || !processes) return;
+    if (!scene || !boxRef || !processes || !MaterialRef.current) return;
 
-    // 1. Find the existing object by UUID
     const existingObject = scene.getObjectByProperty("uuid", id);
     if (!existingObject) return;
 
-    // 2. Find the process that targets this object's modelUUID
+    if (boxRef.current?.parent) {
+      boxRef.current.parent.remove(boxRef.current);
+      boxRef.current = null;
+    }
+
     if (boxVisible) {
       const matchedProcess = findProcessByTargetModelUUID(processes, id);
-
+      let materialType: "Box" | "Crate" | "Default" = "Default";
-      // 3. Determine the material (from materialref) if a process is matched
-      let materialType = "Default";
 
       if (matchedProcess) {
         const materialEntry = MaterialRef.current.find((item: any) =>
           item.objects.some((obj: any) => obj.processId === matchedProcess)
         );
-        console.log("materialEntry: ", materialEntry);
         if (materialEntry) {
-          materialType = materialEntry.material; // "Box" or "Crate"
+          materialType = materialEntry.material;
         }
       }
 
-      // 4. Create the box mesh with the assigned material
       const boxGeometry = new THREE.BoxGeometry(0.5, 0.5, 0.5);
-      const boxMaterial = baseMaterials[materialType as MaterialType];
+      const boxMesh = new THREE.Mesh(boxGeometry, baseMaterials[materialType]);
-      const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial);
       boxMesh.position.y = 1;
       boxMesh.name = `box-${id}`;
-
-      // 5. Add to scene and cleanup
       existingObject.add(boxMesh);
       boxRef.current = boxMesh;
     }
 
-    if (!startPointReached.current && boxVisible) {
-      setBoxVisible(false);
-    }
     return () => {
       if (boxRef.current?.parent) {
         boxRef.current.parent.remove(boxRef.current);
       }
-      boxRef.current = null;
     };
-  }, [
+  }, [processes, MaterialRef, boxVisible, scene, id, baseMaterials]);
-    processes,
-    MaterialRef,
-    boxVisible,
-    findProcessByTargetModelUUID,
-    startPointReached,
-  ]);
 
   useFrame((_, delta) => {
-    const currentAgv = (agvRef.current || []).find(
+    const currentAgv = (agvRef.current || []).find((agv: AGVData) => agv.vehicleId === id);
-      (agv: AGVData) => agv.vehicleId === id
-    );
 
     if (!scene || !id || !isPlaying) return;
 
@@ -283,7 +230,6 @@ export default function PathNavigator({
 
     if (isPlaying && !hasStarted.current) {
       hasStarted.current = false;
-      startPointReached.current = false;
       progressRef.current = 0;
       isWaiting.current = false;
       if (timeoutRef.current) {
@@ -295,10 +241,9 @@ export default function PathNavigator({
     const isAgvReady = () => {
       if (!agvRef.current || agvRef.current.length === 0) return false;
       if (!currentAgv) return false;
-      return hitCount === currentAgv.expectedHitCount;
+      return currentAgv.isActive && hitCount >= currentAgv.maxHitCount;
     };
 
-    // Step 1: Snap to start point on first play
     if (isPlaying && !hasStarted.current && toPickupPath.length > 0) {
       setBoxVisible(false);
       const startPoint = new THREE.Vector3(...toPickupPath[0]);
@@ -311,146 +256,132 @@ export default function PathNavigator({
       }
 
       hasStarted.current = true;
-      startPointReached.current = true;
       progressRef.current = 0;
-
+      hasReachedPickup.current = false;
       setToPickupPath(toPickupPath.slice(-1));
-
+      logAgvStatus(id, "Started from station, heading to pickup");
       return;
     }
 
-    // Step 2: Wait at start point for AGV readiness
+    if (isPlaying && currentPhase === "initial" && !hasReachedPickup.current) {
-    if (isPlaying && startPointReached.current && path.length === 0) {
+      const reached = moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
-      if (!isAgvReady()) {
+
-        return; // Prevent transitioning to the next phase if AGV is not ready
+      if (reached) {
+        hasReachedPickup.current = true;
+        if (currentAgv) {
+          currentAgv.status = 'picking';
+        }
+        logAgvStatus(id, "Reached pickup point, Waiting for material");
       }
-
-      setBoxVisible(true);
-
-      setPath([...toPickupPath]); // Start path transition once the AGV is ready
-      setCurrentPhase("toDrop");
-      progressRef.current = 0;
-      console.log("startPointReached: ", startPointReached.current);
-      startPointReached.current = false;
-
       return;
     }
 
-    if (path.length < 2) return;
+    if (isPlaying && currentAgv?.isActive && currentPhase === "initial") {
+      if (!isAgvReady()) return;
+      setTimeout(() => {
+        setBoxVisible(true);
+        setPath([...pickupDropPath]);
+        setCurrentPhase("toDrop");
+        progressRef.current = 0;
+        logAgvStatus(id, "Started from pickup point, heading to drop point");
+        if (currentAgv) {
+          currentAgv.status = 'toDrop';
+        }
+      }, 0)
+      return;
+    }
+
+    if (isPlaying && currentPhase === "toDrop") {
+      const reached = moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
+
+      if (reached && !isWaiting.current) {
+        isWaiting.current = true;
+        logAgvStatus(id, "Reached drop point");
+        if (currentAgv) {
+          currentAgv.status = 'droping';
+        }
+        timeoutRef.current = setTimeout(() => {
+          setPath([...dropPickupPath]);
+          setCurrentPhase("toPickup");
+          progressRef.current = 0;
+          isWaiting.current = false;
+          setBoxVisible(false);
+          if (currentAgv) {
+            currentAgv.status = 'toPickup';
+          }
+          logAgvStatus(id, "Started from droping point, heading to pickup point");
+        }, bufferTime * 1000);
+      }
+      return;
+    }
+
+    if (isPlaying && currentPhase === "toPickup") {
+      const reached = moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
+
+      if (reached) {
+        if (currentAgv) {
+          currentAgv.isActive = false;
+        }
+        setCurrentPhase("initial");
+        if (currentAgv) {
+          currentAgv.status = 'picking';
+        }
+        logAgvStatus(id, "Reached pickup point again, cycle complete");
+      }
+      return;
+    }
+
+    moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
+  });
+
+  function moveAlongPath(
+    object: THREE.Object3D,
+    path: [number, number, number][],
+    distances: number[],
+    speed: number,
+    delta: number,
+    progressRef: React.MutableRefObject<number>
+  ): boolean {
+    if (path.length < 2) return false;
 
     progressRef.current += delta * speed;
-
     let covered = progressRef.current;
     let accumulated = 0;
     let index = 0;
 
-    if (distancesRef.current.length !== path.length - 1) {
+    for (; index < distances.length; index++) {
-      distancesRef.current = [];
+      const dist = distances[index];
-      totalDistanceRef.current = 0;
+      if (accumulated + dist >= covered) break;
+      accumulated += dist;
+    }
 
-      for (let i = 0; i < path.length - 1; i++) {
+    if (index >= path.length - 1) {
-        const start = new THREE.Vector3(...path[i]);
+      if (path.length > 1) {
-        const end = new THREE.Vector3(...path[i + 1]);
+        const lastDirection = new THREE.Vector3(...path[path.length - 1])
-        const distance = start.distanceTo(end);
+          .sub(new THREE.Vector3(...path[path.length - 2]))
-        distancesRef.current.push(distance);
+          .normalize();
-        totalDistanceRef.current += distance;
+        object.rotation.y = Math.atan2(lastDirection.x, lastDirection.z);
       }
+      return true;
     }
 
-    while (
-      index < distancesRef.current.length &&
-      covered > accumulated + distancesRef.current[index]
-    ) {
-      accumulated += distancesRef.current[index];
-      index++;
-    }
-
-    // AGV has completed its path
-    if (index >= distancesRef.current.length) {
-      progressRef.current = totalDistanceRef.current;
-
-      timeoutRef.current = setTimeout(() => {
-        if (!isAgvReady()) {
-          isWaiting.current = false;
-          return;
-        }
-
-        let nextPath = [];
-        let nextPhase = currentPhase;
-
-        if (currentPhase === "toDrop") {
-          nextPath = dropPickupPath;
-          nextPhase = "toPickup";
-          setBoxVisible(false);
-        } else if (currentPhase === "toPickup") {
-          // When returning to start point (toPickup phase completed)
-          // Set position to toPickupPath[1] instead of [0]
-          if (toPickupPath.length > 1) {
-            object.position.copy(new THREE.Vector3(...toPickupPath[1]));
-            // Also set rotation towards the next point if available
-            if (toPickupPath.length > 2) {
-              const nextPoint = new THREE.Vector3(...toPickupPath[2]);
-              const direction = nextPoint
-                .clone()
-                .sub(object.position)
-                .normalize();
-              object.rotation.y = Math.atan2(direction.x, direction.z);
-            }
-          }
-
-          // Reset the path and mark start point as reached
-          setPath([]);
-          startPointReached.current = true;
-          progressRef.current = 0;
-          distancesRef.current = [];
-
-          // Stop the AGV by setting isplaying to false
-          if (currentAgv) {
-            currentAgv.isplaying = false;
-          }
-
-          // Clear timeout and return to prevent further movement
-          if (timeoutRef.current) {
-            clearTimeout(timeoutRef.current);
-            timeoutRef.current = null;
-          }
-          return;
-        } else {
-          nextPath = pickupDropPath;
-          nextPhase = "toDrop";
-          setBoxVisible(true);
-        }
-
-        setPath([...nextPath]);
-        setCurrentPhase(nextPhase);
-        progressRef.current = 0;
-        isWaiting.current = false;
-        distancesRef.current = [];
-
-        // Reset hit count for the next cycle
-        if (agvRef.current) {
-          agvRef.current = agvRef.current.map((agv: AGVData) =>
-            agv.vehicleId === id ? { ...agv, hitCount: 0 } : agv
-          );
-        }
-      }, bufferTime * 1000);
-
-      return;
-    }
-
-    // Step 4: Interpolate position and rotation
     const start = new THREE.Vector3(...path[index]);
     const end = new THREE.Vector3(...path[index + 1]);
-    const dist = distancesRef.current[index];
+    const dist = distances[index];
-
-    if (!dist || dist === 0) return;
 
     const t = THREE.MathUtils.clamp((covered - accumulated) / dist, 0, 1);
     object.position.copy(start.clone().lerp(end, t));
 
-    const direction = new THREE.Vector3().subVectors(end, start).normalize();
+    if (dist > 0.1) {
-    object.rotation.y = Math.atan2(direction.x, direction.z);
+      const targetDirection = end.clone().sub(start).normalize();
-  });
+      const targetRotationY = Math.atan2(targetDirection.x, targetDirection.z);
+
+      const rotationSpeed = Math.min(5 * delta, 1);
+      object.rotation.y = THREE.MathUtils.lerp(object.rotation.y, targetRotationY, rotationSpeed);
+    }
+
+    return false;
+  }
 
   useEffect(() => {
     return () => {

app/src/modules/scene/IntialLoad/loadInitialFloorItems.ts

@@ -20,7 +20,6 @@ async function loadInitialFloorItems(
     const organization = (email!.split("@")[1]).split(".")[0];
 
     const items = await getFloorAssets(organization);
-    console.log('items: ', items);
     localStorage.setItem("FloorItems", JSON.stringify(items));
     await initializeDB();
 

app/src/modules/scene/controls/selection/selectionControls.tsx

@@ -14,7 +14,6 @@ import CopyPasteControls from "./copyPasteControls";
 import MoveControls from "./moveControls";
 import RotateControls from "./rotateControls";
 import useModuleStore from "../../../../store/useModuleStore";
-import { detectModifierKeys } from "../../../../utils/shortcutkeys/detectModifierKeys";
 
 const SelectionControls: React.FC = () => {
     const { camera, controls, gl, scene, pointer } = useThree();
@@ -102,13 +101,12 @@ const SelectionControls: React.FC = () => {
         };
 
         const onKeyDown = (event: KeyboardEvent) => {
-            const keyCombination = detectModifierKeys(event);
             if (movedObjects.length > 0 || rotatedObjects.length > 0) return;
-            if (keyCombination === "ESCAPE") {
+            if (event.key.toLowerCase() === "escape") {
                 event.preventDefault();
                 clearSelection();
             }
-            if (keyCombination === "DELETE") {
+            if (event.key.toLowerCase() === "delete") {
                 event.preventDefault();
                 deleteSelection();
             }

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

@@ -26,6 +26,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
 }) => {
   const gltf = useLoader(GLTFLoader, crate) as GLTF;
   const groupRef = useRef<THREE.Group>(null);
+  const tempStackedObjectsRef = useRef<Record<string, boolean>>({});
 
   const {
     animationStates,
@@ -43,27 +44,19 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
     checkAndCountTriggers,
   } = useProcessAnimation(processes, setProcesses, agvRef);
 
-  const baseMaterials = useMemo(
+  const baseMaterials = useMemo(() => ({
-    () => ({
+    Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
-      Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
+    Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
-      Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
+    Default: new THREE.MeshStandardMaterial(),
-      // Default: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
+  }), []);
-      Default: new THREE.MeshStandardMaterial(),
-    }),
-    []
-  );
 
   useEffect(() => {
     // Update material references for all spawned objects
     Object.entries(animationStates).forEach(([processId, processState]) => {
       Object.keys(processState.spawnedObjects).forEach((objectId) => {
-        const entry = {
+        const entry = { processId, objectId, };
-          processId,
-          objectId,
-        };
 
-        const materialType =
+        const materialType = processState.spawnedObjects[objectId]?.currentMaterialType;
-          processState.spawnedObjects[objectId]?.currentMaterialType;
 
         if (!materialType) {
           return;
@@ -72,17 +65,13 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
         const matRefArray = MaterialRef.current;
 
         // Find existing material group
-        const existing = matRefArray.find(
+        const existing = matRefArray.find((entryGroup: { material: string; objects: any[] }) =>
-          (entryGroup: { material: string; objects: any[] }) =>
+          entryGroup.material === materialType
-            entryGroup.material === materialType
         );
 
         if (existing) {
           // Check if this processId + objectId already exists
-          const alreadyExists = existing.objects.some(
+          const alreadyExists = existing.objects.some((o: any) => o.processId === entry.processId && o.objectId === entry.objectId);
-            (o: any) =>
-              o.processId === entry.processId && o.objectId === entry.objectId
-          );
 
           if (!alreadyExists) {
             existing.objects.push(entry);
@@ -102,8 +91,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
 
   useFrame(() => {
     // Spawn logic frame
-    const currentTime =
+    const currentTime = clockRef.current.getElapsedTime() - elapsedBeforePauseRef.current;
-      clockRef.current.getElapsedTime() - elapsedBeforePauseRef.current;
 
     setAnimationStates((prev) => {
       const newStates = { ...prev };
@@ -131,10 +119,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
             : parseFloat(spawnAction.spawnInterval as string) || 0;
 
         // Check if this is a zero interval spawn and we already spawned an object
-        if (
+        if (spawnInterval === 0 && processState.hasSpawnedZeroIntervalObject === true) {
-          spawnInterval === 0 &&
-          processState.hasSpawnedZeroIntervalObject === true
-        ) {
           return; // Don't spawn more objects for zero interval
         }
 
@@ -312,28 +297,81 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
             //   }
             // }
 
+            // if (isLastPoint) {
+            //   if (currentPointData?.actions) {
+            //     const hasNonInherit = hasNonInheritActions(
+            //       currentPointData.actions
+            //     );
+            //     if (!hasNonInherit) {
+            //       // Remove the object if all actions are inherit
+            //       updatedObjects[objectId] = {
+            //         ...obj,
+            //         visible: false,
+            //         state: { ...stateRef, isAnimating: false },
+            //       };
+            //       return;
+            //     }
+            //   } else {
+            //     // No actions at last point - remove the object
+            //     updatedObjects[objectId] = {
+            //       ...obj,
+            //       visible: false,
+            //       state: { ...stateRef, isAnimating: false },
+            //     };
+            //     return;
+            //   }
+            // }
+
             if (isLastPoint) {
-              if (currentPointData?.actions) {
+              const isAgvPicking = agvRef.current.some(
-                const hasNonInherit = hasNonInheritActions(
+                (agv: any) => agv.processId === process.id && agv.status === "picking"
-                  currentPointData.actions
+              );
-                );
+
-                if (!hasNonInherit) {
+              const shouldHide = !currentPointData?.actions || !hasNonInheritActions(currentPointData.actions);
-                  // Remove the object if all actions are inherit
+
+              if (shouldHide) {
+                if (isAgvPicking) {
                   updatedObjects[objectId] = {
                     ...obj,
                     visible: false,
-                    state: { ...stateRef, isAnimating: false },
+                    state: {
+                      ...stateRef,
+                      isAnimating: false,
+                    },
+                  };
+                } else {
+                  tempStackedObjectsRef.current[objectId] = true;
+
+                  updatedObjects[objectId] = {
+                    ...obj,
+                    visible: true,
+                    state: {
+                      ...stateRef,
+                      isAnimating: true,
+                    },
                   };
-                  return;
                 }
-              } else {
+
-                // No actions at last point - remove the object
+                return;
+              }
+            }
+
+            if (tempStackedObjectsRef.current[objectId]) {
+              const isAgvPicking = agvRef.current.some(
+                (agv: any) => agv.processId === process.id && agv.status === "picking"
+              );
+
+              if (isAgvPicking) {
+                delete tempStackedObjectsRef.current[objectId];
+
                 updatedObjects[objectId] = {
                   ...obj,
                   visible: false,
-                  state: { ...stateRef, isAnimating: false },
+                  state: {
+                    ...stateRef,
+                    isAnimating: false,
+                  },
                 };
-                return;
               }
             }
 

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

@@ -57,7 +57,7 @@
 //   pointActions: PointAction[][];
 //   pointTriggers: PointTrigger[][];
 //   speed: number;
-//   isplaying: boolean;
+//   isActive: boolean;
 // }
 
 // interface ProcessCreatorProps {
@@ -147,7 +147,7 @@
 //   pointActions: [],
 //   pointTriggers: [], // Added point triggers array
 //   speed: 1,
-//   isplaying: false,
+//   isActive: false,
 // });
 
 // // Enhanced connection checking function
@@ -283,7 +283,7 @@
 //         pointActions,
 //         pointTriggers,
 //         speed: processSpeed,
-//         isplaying: false,
+//         isActive: false,
 //       };
 //     },
 //     [scene]
@@ -410,7 +410,7 @@
 //             p.connections.targets.map((t: { modelUUID: string }) => t.modelUUID)
 //           )
 //           .join(","),
-//         isplaying: false,
+//         isActive: false,
 //       }));
 //     }, [convertedPaths]);
 
@@ -459,6 +459,7 @@ import {
   ConveyorEventsSchema,
   VehicleEventsSchema,
 } from "../../../types/world/worldTypes";
+import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
 
 // Type definitions
 export interface PointAction {
@@ -495,7 +496,7 @@ export interface SimulationPath {
   points: PathPoint[];
   pathPosition: [number, number, number];
   speed?: number;
-  isplaying: boolean;
+  isActive: boolean;
 }
 
 export interface Process {
@@ -505,7 +506,7 @@ export interface Process {
   pointActions: PointAction[][];
   pointTriggers: PointTrigger[][];
   speed: number;
-  isplaying: boolean;
+  isActive: boolean;
 }
 
 interface ProcessCreatorProps {
@@ -538,13 +539,13 @@ function convertToSimulationPath(
         actions: Array.isArray(point.actions)
           ? point.actions.map(normalizeAction)
           : point.actions
-          ? [normalizeAction(point.actions)]
+            ? [normalizeAction(point.actions)]
-          : [],
+            : [],
         triggers: Array.isArray(point.triggers)
           ? point.triggers.map(normalizeTrigger)
           : point.triggers
-          ? [normalizeTrigger(point.triggers)]
+            ? [normalizeTrigger(point.triggers)]
-          : [],
+            : [],
         connections: {
           targets: point.connections.targets.map((target) => ({
             modelUUID: target.modelUUID,
@@ -556,7 +557,7 @@ function convertToSimulationPath(
         typeof path.speed === "string"
           ? parseFloat(path.speed) || 1
           : path.speed || 1,
-      isplaying: false, // Added missing property
+      isActive: false, // Added missing property
     };
   } else {
     // For vehicle paths, handle the case where triggers might not exist
@@ -570,8 +571,8 @@ function convertToSimulationPath(
           actions: Array.isArray(path.points.actions)
             ? path.points.actions.map(normalizeAction)
             : path.points.actions
-            ? [normalizeAction(path.points.actions)]
+              ? [normalizeAction(path.points.actions)]
-            : [],
+              : [],
           triggers: [],
           connections: {
             targets: path.points.connections.targets.map((target) => ({
@@ -582,7 +583,7 @@ function convertToSimulationPath(
       ],
       pathPosition: path.position,
       speed: path.points.speed || 1,
-      isplaying: false,
+      isActive: false,
     };
   }
 }
@@ -595,7 +596,7 @@ const createEmptyProcess = (): Process => ({
   pointActions: [],
   pointTriggers: [], // Added point triggers array
   speed: 1,
-  isplaying: false,
+  isActive: false,
 });
 
 // Enhanced connection checking function
@@ -731,7 +732,7 @@ export function useProcessCreation() {
         pointActions,
         pointTriggers,
         speed: processSpeed,
-        isplaying: false,
+        isActive: false,
       };
     },
     [scene]
@@ -824,6 +825,7 @@ const ProcessCreator: React.FC<ProcessCreatorProps> = React.memo(
     const { createProcessesFromPaths } = useProcessCreation();
     const prevPathsRef = useRef<SimulationPath[]>([]);
     const prevProcessesRef = useRef<Process[]>([]);
+    const { isPlaying } = usePlayButtonStore();
 
     const convertedPaths = useMemo((): SimulationPath[] => {
       if (!simulationStates) return [];
@@ -858,7 +860,7 @@ const ProcessCreator: React.FC<ProcessCreatorProps> = React.memo(
             p.connections.targets.map((t: { modelUUID: string }) => t.modelUUID)
           )
           .join(","),
-        isplaying: false,
+        isActive: false,
       }));
     }, [convertedPaths]);
 

app/src/modules/simulation/process/types.ts

@@ -39,7 +39,7 @@ export interface ProcessPath {
   pathRotation: number[];
   speed: number;
   type: "Conveyor" | "Vehicle";
-  isplaying: boolean
+  isActive: boolean
 }
 
 export interface ProcessData {

app/src/modules/simulation/simulation.tsx

@@ -15,7 +15,6 @@ import Agv from "../builder/agv/agv";
 function Simulation() {
   const { activeModule } = useModuleStore();
   const pathsGroupRef = useRef() as React.MutableRefObject<THREE.Group>;
-  const { simulationStates, setSimulationStates } = useSimulationStates();
   const [processes, setProcesses] = useState<any[]>([]);
   const agvRef = useRef([]);
   const MaterialRef = useRef([]);