Refactor simulation paths to simulation states

- Updated all instances of `simulationPaths` to `simulationStates` across multiple components including copyPasteControls, duplicationControls, moveControls, rotateControls, selectionControls, and others.
- Adjusted related state management hooks in the store to reflect the change from `simulationPaths` to `simulationStates`.
- Ensured that all references to simulation paths in the simulation logic and UI components are consistent with the new naming convention.

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

@@ -1,163 +1,91 @@
+import { useEffect, useRef, useState } from "react";
+import { useSimulationStates } from "../../../store/store";
 import PolygonGenerator from "./polygonGenerator";
-import { useThree } from "@react-three/fiber";
-import { useEffect, useMemo, useRef, useState } from "react";
-import * as THREE from "three";
-import * as Types from "../../../types/world/worldTypes";
 import PathNavigator from "./pathNavigator";
 import NavMeshDetails from "./navMeshDetails";
-import {
-  useSelectedActionSphere,
-  useSimulationPaths,
-} from "../../../store/store";
 import * as CONSTANTS from "../../../types/world/worldConstants";
+import * as Types from "../../../types/world/worldTypes";
 
-const Agv = ({
-  lines,
-}: {
-  lines: Types.RefLines;
-}) => {
-  const [pathPoints, setPathPoints] = useState<
-    {
-      modelUuid: string;
-      modelSpeed: number;
-      bufferTime: number;
-      points: { x: number; y: number; z: number }[];
-      hitCount: number;
-    }[]
-  >([]);
-  const { simulationPaths } = useSimulationPaths();
-  const { selectedActionSphere } = useSelectedActionSphere();
-  useEffect(() => {
-    if (!Array.isArray(simulationPaths)) {
-    } else {
-      let agvModels = simulationPaths.filter(
-        (val: any) => val.modelName === "agv"
-      );
+type AgvProps = {
+	lines: Types.RefLines
+};
 
-      
-      let findMesh = agvModels.filter(
-        (val: any) =>
-          val.modeluuid === selectedActionSphere?.path?.modeluuid &&
-          val.type === "Vehicle"
-      );
+type PathPoints = {
+	modelUuid: string;
+	modelSpeed: number;
+	bufferTime: number;
+	points: { x: number; y: number; z: number }[];
+	hitCount: number;
+};
 
-      const result =
-        findMesh.length > 0 &&
-          findMesh[0].type === "Vehicle" &&
-          typeof findMesh[0].points?.actions.start === "object" &&
-          typeof findMesh[0].points?.actions.end === "object" &&
-          "x" in findMesh[0].points.actions.start &&
-          "y" in findMesh[0].points.actions.start &&
-          "x" in findMesh[0].points.actions.end &&
-          "y" in findMesh[0].points.actions.end
-          ? [
-              {
-                modelUuid: findMesh[0].modeluuid, // Ensure it's a number
-                modelSpeed: findMesh[0].points.speed,
-                bufferTime: findMesh[0].points.actions.buffer,
-                hitCount: findMesh[0].points.actions.hitCount,
-                points: [
-                  {
-                    x: findMesh[0].position[0],
-                    y: findMesh[0].position[1],
-                    z: findMesh[0].position[2],
-                  },
-                  {
-                    x: findMesh[0].points.actions.start.x,
-                    y: 0,
-                    z: findMesh[0].points.actions.start.y,
-                  },
-                  {
-                    x: findMesh[0].points.actions.end.x,
-                    y: 0,
-                    z: findMesh[0].points.actions.end.y,
-                  },
-                ],
-              },
-            ]
-          : [];
-      if (result.length > 0) {
-        // setPathPoints((prev) => [...prev, ...result]);
-        setPathPoints((prev) => {
-          const existingIndex = prev.findIndex(
-            (item) => item.modelUuid === result[0].modelUuid
-          );
+const Agv = ({ lines }: AgvProps) => {
 
-          if (existingIndex !== -1) {
-            const updatedPathPoints = [...prev];
-            updatedPathPoints[existingIndex] = result[0];
-            return updatedPathPoints;
-          } else {
-            return [...prev, ...result];
-          }
-        });
-      }
-    }
-    // setPathPoints((prev) => {
-    //   const existingUUIDs = new Set(prev.map((item) => item.uuid));
-    //   const newItems = result.filter(
-    //     (item) => !existingUUIDs.has(item.uuid)
-    //   );
-    //   return [...prev, ...newItems];
-    // });
-  }, [simulationPaths, selectedActionSphere]);
+	let groupRef = useRef() as Types.RefGroup;
+	const [pathPoints, setPathPoints] = useState<PathPoints[]>([]);
+	const { simulationStates } = useSimulationStates();
+	const [navMesh, setNavMesh] = useState();
 
-  let groupRef = useRef() as Types.RefGroup;
-  const [navMesh, setNavMesh] = useState();
+	useEffect(() => {
+		if (simulationStates.length > 0) {
 
-  return (
-    <>
-      <PolygonGenerator groupRef={groupRef} lines={lines} />
-      <NavMeshDetails
-        lines={lines}
-        setNavMesh={setNavMesh}
-        groupRef={groupRef}
-      />
-      {pathPoints.map((pair, i) => (
-        <>
-          <PathNavigator
-            navMesh={navMesh}
-            selectedPoints={pair.points}
-            id={pair.modelUuid}
-            key={i}
-            speed={pair.modelSpeed}
-            bufferTime={pair.bufferTime}
-            hitCount={pair.hitCount}
-          />
-          {/* {pair.points.length > 2 && (
-            <>
-              <mesh
-                position={[
-                  pair.points[1].x,
-                  pair.points[1].y,
-                  pair.points[1].z,
-                ]}
-              >
-                <sphereGeometry args={[0.3, 15, 15]} />
-                <meshStandardMaterial color="red" />
-              </mesh>
-              <mesh
-                position={[
-                  pair.points[2].x,
-                  pair.points[2].y,
-                  pair.points[2].z,
-                ]}
-              >
-                <sphereGeometry args={[0.3, 15, 15]} />
-                <meshStandardMaterial color="red" />
-              </mesh>
-            </>
-          )} */}
-        </>
-      ))}
-      <group ref={groupRef} visible={false} name="Meshes">
-        <mesh rotation-x={CONSTANTS.planeConfig.rotation} position={CONSTANTS.planeConfig.position3D} name="Plane" receiveShadow>
-          <planeGeometry args={[300, 300]} />
-          <meshBasicMaterial color={CONSTANTS.planeConfig.color} />
-        </mesh>
-      </group>
-    </>
-  );
+			const agvModels = simulationStates.filter((val) => val.modelName === "agv" && val.type === "Vehicle");
+
+			const newPathPoints = agvModels.filter((model: any) => 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);
+		}
+	}, [simulationStates]);
+
+	return (
+		<>
+
+			<PolygonGenerator groupRef={groupRef} lines={lines} />
+			<NavMeshDetails lines={lines} setNavMesh={setNavMesh} groupRef={groupRef} />
+
+			{pathPoints.map((pair, i) => (
+				<PathNavigator
+					navMesh={navMesh}
+					selectedPoints={pair.points}
+					id={pair.modelUuid}
+					key={i}
+					speed={pair.modelSpeed}
+					bufferTime={pair.bufferTime}
+					hitCount={pair.hitCount}
+				/>
+			))}
+
+			{pathPoints.map((pair, i) => (
+				<group key={i}>
+					<mesh position={[pair.points[1].x, pair.points[1].y, pair.points[1].z,]} >
+						<sphereGeometry args={[0.3, 15, 15]} />
+						<meshStandardMaterial color="red" />
+					</mesh>
+					<mesh position={[pair.points[2].x, pair.points[2].y, pair.points[2].z,]} >
+						<sphereGeometry args={[0.3, 15, 15]} />
+						<meshStandardMaterial color="red" />
+					</mesh>
+				</group>
+			))}
+
+			<group ref={groupRef} visible={false} name="Meshes">
+				<mesh rotation-x={CONSTANTS.planeConfig.rotation} position={CONSTANTS.planeConfig.position3D} name="Plane" receiveShadow>
+					<planeGeometry args={[300, 300]} />
+					<meshBasicMaterial color={CONSTANTS.planeConfig.color} />
+				</mesh>
+			</group>
+		</>
+	);
 };
 
 export default Agv;

app/src/modules/builder/geomentries/assets/addAssetModel.ts

@@ -24,7 +24,7 @@ async function addAssetModel(
     socket: Socket<any>,
     selectedItem: any,
     setSelectedItem: any,
-    setSimulationPaths: any,
+    setSimulationStates: any,
     plane: Types.RefMesh,
 ): Promise<void> {
 
@@ -65,7 +65,7 @@ async function addAssetModel(
             const cachedModel = THREE.Cache.get(selectedItem.id);
             if (cachedModel) {
                 // console.log(`[Cache] Fetching ${selectedItem.name}`);
-                handleModelLoad(cachedModel, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, setSimulationPaths, socket);
+                handleModelLoad(cachedModel, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, setSimulationStates, socket);
                 return;
             } else {
                 const cachedModelBlob = await retrieveGLTF(selectedItem.id);
@@ -78,7 +78,7 @@ async function addAssetModel(
                         URL.revokeObjectURL(blobUrl);
                         THREE.Cache.remove(blobUrl);
                         THREE.Cache.add(selectedItem.id, gltf);
-                        handleModelLoad(gltf, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, setSimulationPaths, socket);
+                        handleModelLoad(gltf, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, setSimulationStates, socket);
                     },
                         () => {
                             TempLoader(intersectPoint!, isTempLoader, tempLoader, itemsGroup);
@@ -90,7 +90,7 @@ async function addAssetModel(
                         const modelBlob = await fetch(`${url_Backend_dwinzo}/api/v1/AssetFile/${selectedItem.id}`).then((res) => res.blob());
                         await storeGLTF(selectedItem.id, modelBlob);
                         THREE.Cache.add(selectedItem.id, gltf);
-                        await handleModelLoad(gltf, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, setSimulationPaths, socket);
+                        await handleModelLoad(gltf, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, setSimulationStates, socket);
                     },
                         () => {
                             TempLoader(intersectPoint!, isTempLoader, tempLoader, itemsGroup);
@@ -113,7 +113,7 @@ async function handleModelLoad(
     tempLoader: Types.RefMesh,
     isTempLoader: Types.RefBoolean,
     setFloorItems: Types.setFloorItemSetState,
-    setSimulationPaths: any,
+    setSimulationStates: any,
     socket: Socket<any>
 ) {
     const model = gltf.scene.clone();
@@ -219,7 +219,7 @@ async function handleModelLoad(
             eventData.position = newFloorItem.position;
             eventData.rotation = [model.rotation.x, model.rotation.y, model.rotation.z];
 
-            setSimulationPaths((prevEvents: (Types.ConveyorEventsSchema | Types.VehicleEventsSchema)[]) => [
+            setSimulationStates((prevEvents: (Types.ConveyorEventsSchema | Types.VehicleEventsSchema)[]) => [
                 ...(prevEvents || []),
                 eventData as Types.ConveyorEventsSchema
             ]);
@@ -281,7 +281,7 @@ async function handleModelLoad(
                 return updatedItems;
             });
 
-            setSimulationPaths((prevEvents: (Types.ConveyorEventsSchema | Types.VehicleEventsSchema)[]) => [
+            setSimulationStates((prevEvents: (Types.ConveyorEventsSchema | Types.VehicleEventsSchema)[]) => [
                 ...(prevEvents || []),
                 eventData as Types.VehicleEventsSchema
             ]);

app/src/modules/builder/geomentries/assets/deleteFloorItems.ts

@@ -10,7 +10,7 @@ async function DeleteFloorItems(
     itemsGroup: Types.RefGroup,
     hoveredDeletableFloorItem: Types.RefMesh,
     setFloorItems: Types.setFloorItemSetState,
-    setSimulationPaths: any,
+    setSimulationStates: any,
     socket: Socket<any>
 ): Promise<void> {
 
@@ -76,7 +76,7 @@ async function DeleteFloorItems(
             }
             setFloorItems(updatedItems);
 
-            setSimulationPaths((prevEvents: (Types.ConveyorEventsSchema | Types.VehicleEventsSchema)[]) => {
+            setSimulationStates((prevEvents: (Types.ConveyorEventsSchema | Types.VehicleEventsSchema)[]) => {
                 const updatedEvents = (prevEvents || []).filter(event => event.modeluuid !== removedItem.modeluuid);
                 return updatedEvents;
             });

app/src/modules/builder/groups/floorItemsGroup.tsx

@@ -10,7 +10,7 @@ import {
   useRenderDistance,
   useselectedFloorItem,
   useSelectedItem,
-  useSimulationPaths,
+  useSimulationStates,
   useSocketStore,
   useToggleView,
   useTransformMode,
@@ -65,7 +65,7 @@ const FloorItemsGroup = ({
   const { setselectedFloorItem } = useselectedFloorItem();
   const { activeTool } = useActiveTool();
   const { selectedItem, setSelectedItem } = useSelectedItem();
-  const { simulationPaths, setSimulationPaths } = useSimulationPaths();
+  const { simulationStates, setSimulationStates } = useSimulationStates();
   const { setLoadingProgress } = useLoadingProgress();
   const { activeModule } = useModuleStore();
   const { socket } = useSocketStore();
@@ -111,7 +111,7 @@ const FloorItemsGroup = ({
         gltfLoaderWorker.postMessage({ floorItems: data });
       } else {
         gltfLoaderWorker.postMessage({ floorItems: [] });
-        loadInitialFloorItems(itemsGroup, setFloorItems, setSimulationPaths);
+        loadInitialFloorItems(itemsGroup, setFloorItems, setSimulationStates);
         updateLoadingProgress(100);
       }
     });
@@ -130,7 +130,7 @@ const FloorItemsGroup = ({
           updateLoadingProgress(progress);
 
           if (loadedAssets === totalAssets) {
-            loadInitialFloorItems(itemsGroup, setFloorItems, setSimulationPaths);
+            loadInitialFloorItems(itemsGroup, setFloorItems, setSimulationStates);
             updateLoadingProgress(100);
           }
         });
@@ -248,7 +248,7 @@ const FloorItemsGroup = ({
             itemsGroup,
             hoveredDeletableFloorItem,
             setFloorItems,
-            setSimulationPaths,
+            setSimulationStates,
             socket
           );
         }
@@ -374,7 +374,7 @@ const FloorItemsGroup = ({
           socket,
           selectedItem,
           setSelectedItem,
-          setSimulationPaths,
+          setSimulationStates,
           plane
         );
       }