Merge remote-tracking branch 'origin/v2' into simulation-agv-v2

app/src/components/layout/sidebarRight/properties/eventProperties/components/ActionsList.tsx

@@ -35,7 +35,7 @@ const ActionsList: React.FC<ActionsListProps> = ({
 
     const handleRenameAction = (newName: string) => {
         if (!selectedAction.actionId) return;
-        const event = renameAction(selectedAction.actionId, newName);
+        const event = renameAction(selectedProduct.productId, selectedAction.actionId, newName);
 
         if (event) {
             upsertProductOrEventApi({

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/conveyorMechanics.tsx

@@ -72,7 +72,7 @@ function ConveyorMechanics() {
         const validOption = option as | "default" | "spawn" | "swap" | "delay" | "despawn";
         setActiveOption(validOption);
 
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             actionType: validOption,
         });
 
@@ -88,7 +88,7 @@ function ConveyorMechanics() {
 
     const handleRenameAction = (newName: string) => {
         if (!selectedEventData || !selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, { actionName: newName });
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, { actionName: newName });
 
         if (event) {
             updateBackend(
@@ -102,7 +102,7 @@ function ConveyorMechanics() {
 
     const handleSpawnCountChange = (value: string) => {
         if (!selectedEventData || !selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             spawnCount: value === "inherit" ? "inherit" : parseFloat(value),
         });
 
@@ -118,7 +118,7 @@ function ConveyorMechanics() {
 
     const handleSpawnIntervalChange = (value: string) => {
         if (!selectedEventData || !selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             spawnInterval: value === "inherit" ? "inherit" : parseFloat(value),
         });
 
@@ -134,7 +134,7 @@ function ConveyorMechanics() {
 
     const handleMaterialSelect = (material: string) => {
         if (!selectedEventData || !selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, { material });
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, { material });
 
         if (event) {
             updateBackend(
@@ -148,7 +148,7 @@ function ConveyorMechanics() {
 
     const handleDelayChange = (value: string) => {
         if (!selectedEventData || !selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             delay: value === "inherit" ? "inherit" : parseFloat(value),
         });
 

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/machineMechanics.tsx

@@ -51,7 +51,7 @@ function MachineMechanics() {
         const validOption = option as "process";
         setActiveOption(validOption);
 
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             actionType: validOption,
         });
 
@@ -67,19 +67,19 @@ function MachineMechanics() {
 
     const handleRenameAction = (newName: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, { actionName: newName });
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, { actionName: newName });
     };
 
     const handleProcessTimeChange = (value: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             processTime: parseFloat(value),
         });
     };
 
     const handleMaterialSelect = (material: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             swapMaterial: material,
         });
     };

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/roboticArmMechanics.tsx

@@ -59,7 +59,7 @@ function RoboticArmMechanics() {
 
     const handleRenameAction = (newName: string) => {
         if (!selectedAction.actionId) return;
-        const event = updateAction(selectedAction.actionId, { actionName: newName });
+        const event = updateAction(selectedProduct.productId, selectedAction.actionId, { actionName: newName });
 
         if (selectedPointData) {
             const updatedActions = selectedPointData.actions.map((action) =>
@@ -101,7 +101,7 @@ function RoboticArmMechanics() {
         if (!selectedAction.actionId || !selectedPointData) return;
         const [x, y, z] = value.split(",").map(Number);
 
-        const event = updateAction(selectedAction.actionId, {
+        const event = updateAction(selectedProduct.productId, selectedAction.actionId, {
             process: {
                 startPoint: [x, y, z] as [number, number, number],
                 endPoint: selectedPointData.actions.find((a) => a.actionUuid === selectedAction.actionId)?.process.endPoint || null,
@@ -122,7 +122,7 @@ function RoboticArmMechanics() {
         if (!selectedAction.actionId || !selectedPointData) return;
         const [x, y, z] = value.split(",").map(Number);
 
-        const event = updateAction(selectedAction.actionId, {
+        const event = updateAction(selectedProduct.productId, selectedAction.actionId, {
             process: {
                 startPoint: selectedPointData.actions.find((a) => a.actionUuid === selectedAction.actionId)?.process.startPoint || null,
                 endPoint: [x, y, z] as [number, number, number],
@@ -181,7 +181,7 @@ function RoboticArmMechanics() {
     const handleDeleteAction = (actionUuid: string) => {
         if (!selectedPointData) return;
 
-        const event = removeAction(actionUuid);
+        const event = removeAction(selectedProduct.productId, actionUuid);
 
         if (event) {
             updateBackend(

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/storageMechanics.tsx

@@ -51,7 +51,7 @@ function StorageMechanics() {
         const validOption = option as "store" | "spawn";
         setActiveOption(validOption);
 
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             actionType: validOption,
         });
 
@@ -67,7 +67,7 @@ function StorageMechanics() {
 
     const handleRenameAction = (newName: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, { actionName: newName });
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, { actionName: newName });
 
         if (event) {
             updateBackend(
@@ -81,7 +81,7 @@ function StorageMechanics() {
 
     const handleCapacityChange = (value: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             storageCapacity: parseInt(value),
         });
 

app/src/components/layout/sidebarRight/properties/eventProperties/mechanics/vehicleMechanics.tsx

@@ -72,7 +72,7 @@ function VehicleMechanics() {
         const validOption = option as "travel";
         setActiveOption(validOption);
 
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             actionType: validOption,
         });
 
@@ -88,7 +88,7 @@ function VehicleMechanics() {
 
     const handleRenameAction = (newName: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, { actionName: newName });
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, { actionName: newName });
 
         if (event) {
             updateBackend(
@@ -102,7 +102,7 @@ function VehicleMechanics() {
 
     const handleLoadCapacityChange = (value: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             loadCapacity: parseFloat(value),
         });
 
@@ -118,7 +118,7 @@ function VehicleMechanics() {
 
     const handleUnloadDurationChange = (value: string) => {
         if (!selectedPointData) return;
-        const event = updateAction(selectedPointData.action.actionUuid, {
+        const event = updateAction(selectedProduct.productId, selectedPointData.action.actionUuid, {
             unLoadDuration: parseFloat(value),
         });
 

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

@@ -202,11 +202,11 @@ function processLoadedModel(
                     rotation: [item.eventData.point?.rotation[0] || 0, item.eventData.point?.rotation[1] || 0, item.eventData.point?.rotation[2] || 0],
                     action: {
                         actionUuid: THREE.MathUtils.generateUUID(),
-                        actionName: "Vehicle Action",
+                        actionName: "Action 1",
                         actionType: "travel",
                         unLoadDuration: 5,
                         loadCapacity: 10,
-                        steeringAngle:0,
+                        steeringAngle: 0,
                         pickUpPoint: null,
                         unLoadPoint: null,
                         triggers: []
@@ -254,7 +254,7 @@ function processLoadedModel(
                     rotation: [item.eventData.point?.rotation[0] || 0, item.eventData.point?.rotation[1] || 0, item.eventData.point?.rotation[2] || 0],
                     action: {
                         actionUuid: THREE.MathUtils.generateUUID(),
-                        actionName: "Process Action",
+                        actionName: "Action 1",
                         actionType: "process",
                         processTime: 10,
                         swapMaterial: "material-id",
@@ -279,7 +279,7 @@ function processLoadedModel(
                     actions: [
                         {
                             actionUuid: THREE.MathUtils.generateUUID(),
-                            actionName: "Pick and Place",
+                            actionName: "Action 1",
                             actionType: "pickAndPlace",
                             process: {
                                 startPoint: [0, 0, 0],

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

@@ -1,9 +1,14 @@
-import React from 'react'
+import React, { useEffect } from 'react'
 import MachineInstances from './instances/machineInstances'
+import { useMachineStore } from '../../../store/simulation/useMachineStore'
+import { useSelectedProduct } from '../../../store/simulation/useSimulationStore';
 
 function Machine() {
+    const { addMachine, addCurrentAction, removeMachine } = useMachineStore();
+    const { selectedProduct } = useSelectedProduct();
 
-    const machineSample: MachineEventSchema = {
+    const machineSample: MachineEventSchema[] = [
+        {
             modelUuid: "machine-1234-5678-9012",
             modelName: "CNC Milling Machine",
             position: [10, 0, 5],
@@ -23,7 +28,15 @@ function Machine() {
                     triggers: []
                 }
             }
-    };
+        }
+    ];
+
+    useEffect(() => {
+        removeMachine(machineSample[0].modelUuid);
+        addMachine(selectedProduct.productId, machineSample[0]);
+
+        // addCurrentAction(machineSample[0].modelUuid, machineSample[0].point.action.actionUuid);
+    }, [])
 
     return (
         <>

app/src/modules/simulation/products/products.tsx

@@ -7,7 +7,7 @@ import { upsertProductOrEventApi } from '../../../services/simulation/UpsertProd
 import { getAllProductsApi } from '../../../services/simulation/getallProductsApi';
 
 function Products() {
-    const { products, addProduct, setProducts } = useProductStore();
+    const { addProduct, setProducts } = useProductStore();
     const { setSelectedProduct } = useSelectedProduct();
 
     useEffect(() => {
@@ -27,9 +27,6 @@ function Products() {
         })
     }, [])
 
-    useEffect(() => {
-    }, [])
-
     return (
         <>
 

app/src/modules/simulation/triggers/connector/triggerConnector.tsx

@@ -171,10 +171,16 @@ function TriggerConnector() {
                     (intersect) =>
                         intersect.object.name === ('Event-Sphere')
                 );
-            if (intersects.length === 0) return;
+            if (intersects.length === 0) {
+                setFirstSelectedPoint(null);
+                return;
+            };
 
             const currentObject = intersects[0].object;
-            if (!currentObject || currentObject.name !== 'Event-Sphere') return;
+            if (!currentObject || currentObject.name !== 'Event-Sphere') {
+                setFirstSelectedPoint(null);
+                return;
+            };
 
             const modelUuid = currentObject.userData.modelUuid;
             const pointUuid = currentObject.userData.pointUuid;
@@ -189,7 +195,10 @@ function TriggerConnector() {
 
                 const event = getEventByModelUuid(selectedProduct.productId, modelUuid);
 
-                if (!point || !event) return;
+                if (!point || !event) {
+                    setFirstSelectedPoint(null);
+                    return;
+                };
 
                 let actionUuid: string | undefined;
                 if ('action' in point && point.action) {
@@ -228,7 +237,7 @@ function TriggerConnector() {
                     };
 
                     if (firstSelectedPoint.actionUuid) {
-                        const event = addTrigger(firstSelectedPoint.actionUuid, trigger);
+                        const event = addTrigger(selectedProduct.productId, firstSelectedPoint.actionUuid, trigger);
 
                         if (event) {
                             updateBackend(
@@ -254,7 +263,12 @@ function TriggerConnector() {
                     pointUuid
                 );
 
-                if (!point) return;
+                const event = getEventByModelUuid(selectedProduct.productId, modelUuid);
+
+                if (!point || !event) {
+                    setFirstSelectedPoint(null);
+                    return;
+                };
 
                 let actionUuid: string | undefined;
                 if ('action' in point && point.action) {
@@ -270,12 +284,12 @@ function TriggerConnector() {
                     delay: 0,
                     triggeredAsset: {
                         triggeredModel: {
-                            modelName: currentObject.parent?.parent?.name || 'Unknown',
+                            modelName: event.modelName || 'Unknown',
                             modelUuid: modelUuid
                         },
                         triggeredPoint: {
-                            pointName: currentObject.name,
+                            pointName: 'Point',
-                            pointUuid: pointUuid
+                            pointUuid: point.uuid
                         },
                         triggeredAction: actionUuid ? {
                             actionName: getActionByUuid(selectedProduct.productId, actionUuid)?.actionName || 'Action',
@@ -285,13 +299,24 @@ function TriggerConnector() {
                 };
 
                 if (firstSelectedPoint.actionUuid) {
-                    addTrigger(firstSelectedPoint.actionUuid, trigger);
+                    const event = addTrigger(selectedProduct.productId, firstSelectedPoint.actionUuid, trigger);
+
+                    if (event) {
+                        updateBackend(
+                            selectedProduct.productName,
+                            selectedProduct.productId,
+                            organization,
+                            event
+                        );
                     }
+                }
+                setFirstSelectedPoint(null);
+            } else if (firstSelectedPoint) {
                 setFirstSelectedPoint(null);
             }
         };
 
-        if (subModule === 'simulations') {
+        if (subModule === 'simulations' && !deleteTool) {
             canvasElement.addEventListener("mousedown", onMouseDown);
             canvasElement.addEventListener("mouseup", onMouseUp);
             canvasElement.addEventListener("mousemove", onMouseMove);
@@ -305,7 +330,7 @@ function TriggerConnector() {
             canvasElement.removeEventListener('contextmenu', handleRightClick);
         };
 
-    }, [gl, subModule, selectedProduct, firstSelectedPoint]);
+    }, [gl, subModule, selectedProduct, firstSelectedPoint, deleteTool]);
 
 
     useFrame(() => {
@@ -373,9 +398,8 @@ function TriggerConnector() {
 
     const removeConnection = (connection: ConnectionLine) => {
         if (connection.trigger.triggerUuid) {
-            const event = removeTrigger(connection.trigger.triggerUuid);
+            const event = removeTrigger(selectedProduct.productId, connection.trigger.triggerUuid);
             if (event) {
-                console.log('event: ', event);
                 updateBackend(
                     selectedProduct.productName,
                     selectedProduct.productId,

app/src/modules/simulation/vehicle/vehicles.tsx

@@ -1,45 +1,46 @@
-import React, { useEffect, useState } from "react";
+import React, { useEffect } from "react";
 import VehicleInstances from "./instances/vehicleInstances";
 import { useVehicleStore } from "../../../store/simulation/useVehicleStore";
-import { useFloorItems } from "../../../store/store";
 import { useSelectedEventData, useSelectedEventSphere, useSelectedProduct } from "../../../store/simulation/useSimulationStore";
 import VehicleUI from "../ui/vehicle/vehicleUI";
 import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
 import { useProductStore } from "../../../store/simulation/useProductStore";
 
 function Vehicles() {
-    const { getProductById } = useProductStore();
+    const { products, getProductById } = useProductStore();
     const { selectedProduct } = useSelectedProduct();
-    const { vehicles, addVehicle, removeVehicle } = useVehicleStore();
+    const { vehicles, addVehicle, clearvehicles } = useVehicleStore();
     const { selectedEventSphere } = useSelectedEventSphere();
     const { selectedEventData } = useSelectedEventData();
-    const { floorItems } = useFloorItems();
     const { isPlaying } = usePlayButtonStore();
 
     useEffect(() => {
         if (selectedProduct.productId) {
             const product = getProductById(selectedProduct.productId);
             if (product) {
+                clearvehicles();
                 product.eventDatas.forEach(events => {
                     if (events.type === 'vehicle') {
-                        removeVehicle(events.modelUuid);
                         addVehicle(selectedProduct.productId, events);
                     }
                 });
             }
         }
-    }, [selectedProduct]);
+    }, [selectedProduct, products]);
-    useEffect(() => {
 
+    useEffect(() => {
         // console.log('vehicles: ', vehicles);
     }, [vehicles])
 
     return (
         <>
+
             <VehicleInstances />
+
             {selectedEventSphere && selectedEventData?.data.type === "vehicle" && !isPlaying &&
                 < VehicleUI />
             }
+
         </>
     );
 }

app/src/modules/visualization/RealTimeVisulization.tsx

@@ -66,8 +66,7 @@ const RealTimeVisulization: React.FC = () => {
   const { selectedZone, setSelectedZone } = useSelectedZoneStore();
 
   const { setRightSelect } = useRightSelected();
-  const { editWidgetOptions, setEditWidgetOptions } =
+  const { editWidgetOptions, setEditWidgetOptions } = useEditWidgetOptionsStore();
-    useEditWidgetOptionsStore();
   const { rightClickSelected, setRightClickSelected } = useRightClickSelected();
   const [openConfirmationPopup, setOpenConfirmationPopup] = useState(false);
   const { setFloatingWidget } = useFloatingWidget();
@@ -76,8 +75,6 @@ const RealTimeVisulization: React.FC = () => {
   const { setSelectedChartId } = useWidgetStore();
   const [waitingPanels, setWaitingPanels] = useState(null);
 
-  console.log("waitingPanels: ", waitingPanels);
-
   OuterClick({
     contextClassName: [
       "chart-container",

app/src/store/simulation/useArmBotStore.ts

@@ -10,6 +10,7 @@ interface ArmBotStore {
         modelUuid: string,
         updates: Partial<Omit<ArmBotStatus, 'modelUuid' | 'productId'>>
     ) => void;
+    clearArmBots: () => void;
 
     addCurrentAction: (modelUuid: string, actionUuid: string) => void;
     removeCurrentAction: (modelUuid: string) => void;
@@ -39,6 +40,8 @@ export const useArmBotStore = create<ArmBotStore>()(
 
         addArmBot: (productId, event) => {
             set((state) => {
+                const exists = state.armBots.some(a => a.modelUuid === event.modelUuid);
+                if (!exists) {
                     state.armBots.push({
                         ...event,
                         productId,
@@ -47,6 +50,7 @@ export const useArmBotStore = create<ArmBotStore>()(
                         activeTime: 0,
                         state: 'idle',
                     });
+                }
             });
         },
 
@@ -65,6 +69,12 @@ export const useArmBotStore = create<ArmBotStore>()(
             });
         },
 
+        clearArmBots: () => {
+            set((state) => {
+                state.armBots = [];
+            });
+        },
+
         addCurrentAction: (modelUuid, actionUuid) => {
             set((state) => {
                 const armBot = state.armBots.find(a => a.modelUuid === modelUuid);

app/src/store/simulation/useConveyorStore.ts

@@ -10,6 +10,7 @@ interface ConveyorStore {
         modelUuid: string,
         updates: Partial<Omit<ConveyorStatus, 'modelUuid' | 'productId'>>
     ) => void;
+    clearConveyors: () => void;
 
     setConveyorActive: (modelUuid: string, isActive: boolean) => void;
     setConveyorState: (modelUuid: string, newState: ConveyorStatus['state']) => void;
@@ -30,6 +31,8 @@ export const useConveyorStore = create<ConveyorStore>()(
 
         addConveyor: (productId, event) => {
             set((state) => {
+                const exists = state.conveyors.some(c => c.modelUuid === event.modelUuid);
+                if (!exists) {
                     state.conveyors.push({
                         ...event,
                         productId,
@@ -38,6 +41,7 @@ export const useConveyorStore = create<ConveyorStore>()(
                         activeTime: 0,
                         state: 'idle',
                     });
+                }
             });
         },
 
@@ -56,6 +60,12 @@ export const useConveyorStore = create<ConveyorStore>()(
             });
         },
 
+        clearConveyors: () => {
+            set((state) => {
+                state.conveyors = [];
+            });
+        },
+
         setConveyorActive: (modelUuid, isActive) => {
             set((state) => {
                 const conveyor = state.conveyors.find(c => c.modelUuid === modelUuid);

app/src/store/simulation/useEventsStore.ts

@@ -49,7 +49,9 @@ export const useEventsStore = create<EventsStore>()(
         // Event-level actions
         addEvent: (event) => {
             set((state) => {
+                if (!state.events.some(e => 'modelUuid' in e && e.modelUuid === event.modelUuid)) {
                     state.events.push(event);
+                }
             });
         },
 
@@ -76,10 +78,15 @@ export const useEventsStore = create<EventsStore>()(
             set((state) => {
                 const event = state.events.find(e => 'modelUuid' in e && e.modelUuid === modelUuid);
                 if (event && 'points' in event) {
+                    const existingPoint = (event as ConveyorEventSchema).points.find(p => p.uuid === point.uuid);
+                    if (!existingPoint) {
                         (event as ConveyorEventSchema).points.push(point as ConveyorPointSchema);
+                    }
                 } else if (event && 'point' in event) {
+                    if (!(event as any).point || (event as any).point.uuid !== point.uuid) {
                         (event as VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema).point = point as any;
                     }
+                }
             });
         },
 
@@ -113,14 +120,15 @@ export const useEventsStore = create<EventsStore>()(
                 const event = state.events.find(e => 'modelUuid' in e && e.modelUuid === modelUuid);
                 if (event && 'points' in event) {
                     const point = (event as ConveyorEventSchema).points.find(p => p.uuid === pointUuid);
-                    if (point) {
+                    if (point && (!point.action || point.action.actionUuid !== action.actionUuid)) {
                         point.action = action as any;
                     }
                 } else if (event && 'point' in event && (event as any).point.uuid === pointUuid) {
-                    if ('action' in (event as any).point) {
+                    const point = (event as any).point;
-                        (event as any).point.action = action;
+                    if ('action' in point && (!point.action || point.action.actionUuid !== action.actionUuid)) {
-                    } else if ('actions' in (event as any).point) {
+                        point.action = action;
-                        (event as any).point.actions.push(action);
+                    } else if ('actions' in point && !point.actions.some((a: any) => a.actionUuid === action.actionUuid)) {
+                        point.actions.push(action);
                     }
                 }
             });
@@ -183,18 +191,22 @@ export const useEventsStore = create<EventsStore>()(
                     if ('points' in event) {
                         for (const point of (event as ConveyorEventSchema).points) {
                             if (point.action && point.action.actionUuid === actionUuid) {
+                                if (!point.action.triggers.some(t => t.triggerUuid === trigger.triggerUuid)) {
                                     point.action.triggers.push(trigger);
+                                }
                                 return;
                             }
                         }
                     } else if ('point' in event) {
-                        const point = (event as any).point;
+                        const point: MachinePointSchema | VehiclePointSchema = (event as any).point;
                         if ('action' in point && point.action.actionUuid === actionUuid) {
+                            if (!point.action.triggers.some(t => t.triggerUuid === trigger.triggerUuid)) {
                                 point.action.triggers.push(trigger);
+                            }
                             return;
                         } else if ('actions' in point) {
-                            const action = point.actions.find((a: any) => a.actionUuid === actionUuid);
+                            const action = (point as RoboticArmPointSchema).actions.find((a) => a.actionUuid === actionUuid);
-                            if (action) {
+                            if (action && !action.triggers.some(t => t.triggerUuid === trigger.triggerUuid)) {
                                 action.triggers.push(trigger);
                                 return;
                             }

app/src/store/simulation/useMachineStore.ts

@@ -4,23 +4,23 @@ import { immer } from 'zustand/middleware/immer';
 interface MachineStore {
     machines: MachineStatus[];
 
-    // Actions
     addMachine: (productId: string, machine: MachineEventSchema) => void;
     removeMachine: (modelUuid: string) => void;
     updateMachine: (
         modelUuid: string,
         updates: Partial<Omit<MachineStatus, 'modelUuid' | 'productId'>>
     ) => void;
+    clearMachines: () => void;
+
+    addCurrentAction: (modelUuid: string, actionUuid: string) => void;
+    removeCurrentAction: (modelUuid: string) => void;
 
-    // Status updates
     setMachineActive: (modelUuid: string, isActive: boolean) => void;
     setMachineState: (modelUuid: string, newState: MachineStatus['state']) => void;
 
-    // Time tracking
     incrementActiveTime: (modelUuid: string, incrementBy: number) => void;
     incrementIdleTime: (modelUuid: string, incrementBy: number) => void;
 
-    // Helpers
     getMachineById: (modelUuid: string) => MachineStatus | undefined;
     getMachinesByProduct: (productId: string) => MachineStatus[];
     getMachinesBystate: (state: string) => MachineStatus[];
@@ -32,9 +32,10 @@ export const useMachineStore = create<MachineStore>()(
     immer((set, get) => ({
         machines: [],
 
-        // Actions
         addMachine: (productId, machine) => {
             set((state) => {
+                const exists = state.machines.some(m => m.modelUuid === machine.modelUuid);
+                if (!exists) {
                     state.machines.push({
                         ...machine,
                         productId,
@@ -43,6 +44,7 @@ export const useMachineStore = create<MachineStore>()(
                         activeTime: 0,
                         state: 'idle',
                     });
+                }
             });
         },
 
@@ -61,7 +63,36 @@ export const useMachineStore = create<MachineStore>()(
             });
         },
 
-        // Status updates
+        clearMachines: () => {
+            set((state) => {
+                state.machines = [];
+            });
+        },
+
+        addCurrentAction: (modelUuid) => {
+            set((state) => {
+                const armBot = state.machines.find(a => a.modelUuid === modelUuid);
+                if (armBot) {
+                    const action = armBot.point.action;
+                    if (action) {
+                        armBot.currentAction = {
+                            actionUuid: action.actionUuid,
+                            actionName: action.actionName,
+                        };
+                    }
+                }
+            });
+        },
+
+        removeCurrentAction: (modelUuid) => {
+            set((state) => {
+                const armBot = state.machines.find(a => a.modelUuid === modelUuid);
+                if (armBot) {
+                    armBot.currentAction = undefined;
+                }
+            });
+        },
+
         setMachineActive: (modelUuid, isActive) => {
             set((state) => {
                 const machine = state.machines.find(m => m.modelUuid === modelUuid);
@@ -80,7 +111,6 @@ export const useMachineStore = create<MachineStore>()(
             });
         },
 
-        // Time tracking
         incrementActiveTime: (modelUuid, incrementBy) => {
             set((state) => {
                 const machine = state.machines.find(m => m.modelUuid === modelUuid);
@@ -99,7 +129,6 @@ export const useMachineStore = create<MachineStore>()(
             });
         },
 
-        // Helpers
         getMachineById: (modelUuid) => {
             return get().machines.find(m => m.modelUuid === modelUuid);
         },

app/src/store/simulation/useProductStore.ts

@@ -33,27 +33,30 @@ type ProductsStore = {
         pointUuid: string,
         action: ConveyorPointSchema['action'] | VehiclePointSchema['action'] | RoboticArmPointSchema['actions'][0] | MachinePointSchema['action'] | StoragePointSchema['action']
     ) => EventsSchema | undefined;
-    removeAction: (actionUuid: string) => EventsSchema | undefined;
+    removeAction: (productId: string, actionUuid: string) => EventsSchema | undefined;
     updateAction: (
+        productId: string,
         actionUuid: string,
         updates: Partial<ConveyorPointSchema['action'] | VehiclePointSchema['action'] | RoboticArmPointSchema['actions'][0] | MachinePointSchema['action'] | StoragePointSchema['action']>
     ) => EventsSchema | undefined;
 
     // Trigger-level actions
     addTrigger: (
+        productId: string,
         actionUuid: string,
         trigger: TriggerSchema
     ) => EventsSchema | undefined;
-    removeTrigger: (triggerUuid: string) => EventsSchema | undefined;
+    removeTrigger: (productId: string, triggerUuid: string) => EventsSchema | undefined;
     updateTrigger: (
+        productId: string,
         triggerUuid: string,
         updates: Partial<TriggerSchema>
     ) => void;
 
     // Renaming functions
     renameProduct: (productId: string, newName: string) => void;
-    renameAction: (actionUuid: string, newName: string) => EventsSchema | undefined;
+    renameAction: (productId: string, actionUuid: string, newName: string) => EventsSchema | undefined;
-    renameTrigger: (triggerUuid: string, newName: string) => void;
+    renameTrigger: (productId: string, triggerUuid: string, newName: string) => void;
 
     // Helper functions
     getProductById: (productId: string) => { productName: string; productId: string; eventDatas: EventsSchema[] } | undefined;
@@ -71,12 +74,15 @@ export const useProductStore = create<ProductsStore>()(
         // Product-level actions
         addProduct: (productName, productId) => {
             set((state) => {
+                const existingProduct = state.products.find(p => p.productId === productId);
+                if (!existingProduct) {
                     const newProduct = {
                         productName,
                         productId: productId,
                         eventDatas: []
                     };
                     state.products.push(newProduct);
+                }
             });
         },
 
@@ -106,8 +112,11 @@ export const useProductStore = create<ProductsStore>()(
             set((state) => {
                 const product = state.products.find(p => p.productId === productId);
                 if (product) {
+                    const existingEvent = product.eventDatas.find(e => 'modelUuid' in e && e.modelUuid === event.modelUuid);
+                    if (!existingEvent) {
                         product.eventDatas.push(event);
                     }
+                }
             });
         },
 
@@ -120,7 +129,7 @@ export const useProductStore = create<ProductsStore>()(
             });
         },
 
-        deleteEvent: (modelUuid: string) => {
+        deleteEvent: (modelUuid) => {
             set((state) => {
                 for (const product of state.products) {
                     product.eventDatas = product.eventDatas.filter(e => 'modelUuid' in e && e.modelUuid !== modelUuid);
@@ -150,11 +159,17 @@ export const useProductStore = create<ProductsStore>()(
                 if (product) {
                     const event = product.eventDatas.find(e => 'modelUuid' in e && e.modelUuid === modelUuid);
                     if (event && 'points' in event) {
+                        const existingPoint = (event as ConveyorEventSchema).points.find(p => p.uuid === point.uuid);
+                        if (!existingPoint) {
                             (event as ConveyorEventSchema).points.push(point as ConveyorPointSchema);
+                        }
                     } else if (event && 'point' in event) {
+                        const existingPoint = (event as any).point?.uuid === point.uuid;
+                        if (!existingPoint) {
                             (event as VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema).point = point as any;
                         }
                     }
+                }
             });
         },
 
@@ -198,28 +213,34 @@ export const useProductStore = create<ProductsStore>()(
                     const event = product.eventDatas.find(e => 'modelUuid' in e && e.modelUuid === modelUuid);
                     if (event && 'points' in event) {
                         const point = (event as ConveyorEventSchema).points.find(p => p.uuid === pointUuid);
-                        if (point) {
+                        if (point && (!point.action || point.action.actionUuid !== action.actionUuid)) {
                             point.action = action as any;
                             updatedEvent = JSON.parse(JSON.stringify(event));
                         }
                     } else if (event && 'point' in event && (event as any).point.uuid === pointUuid) {
                         if ('action' in (event as any).point) {
+                            if (!(event as any).point.action || (event as any).point.action.actionUuid !== action.actionUuid) {
                                 (event as any).point.action = action;
                                 updatedEvent = JSON.parse(JSON.stringify(event));
+                            }
                         } else if ('actions' in (event as any).point) {
+                            const existingAction = (event as any).point.actions.find((a: any) => a.actionUuid === action.actionUuid);
+                            if (!existingAction) {
                                 (event as any).point.actions.push(action);
                                 updatedEvent = JSON.parse(JSON.stringify(event));
                             }
                         }
                     }
+                }
             });
             return updatedEvent;
         },
 
-        removeAction: (actionUuid: string) => {
+        removeAction: (productId, actionUuid) => {
             let updatedEvent: EventsSchema | undefined;
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             // Handle ConveyorEventSchema
@@ -248,10 +269,11 @@ export const useProductStore = create<ProductsStore>()(
             return updatedEvent;
         },
 
-        updateAction: (actionUuid, updates) => {
+        updateAction: (productId, actionUuid, updates) => {
             let updatedEvent: EventsSchema | undefined;
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             for (const point of (event as ConveyorEventSchema).points) {
@@ -283,30 +305,40 @@ export const useProductStore = create<ProductsStore>()(
         },
 
         // Trigger-level actions
-        addTrigger: (actionUuid, trigger) => {
+        addTrigger: (productId, actionUuid, trigger) => {
             let updatedEvent: EventsSchema | undefined;
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             for (const point of (event as ConveyorEventSchema).points) {
                                 if (point.action && point.action.actionUuid === actionUuid) {
+                                    const existingTrigger = point.action.triggers.find(t => t.triggerUuid === trigger.triggerUuid);
+                                    if (!existingTrigger) {
                                         point.action.triggers.push(trigger);
                                         updatedEvent = JSON.parse(JSON.stringify(event));
+                                    }
                                     return;
                                 }
                             }
                         } else if ('point' in event) {
                             const point = (event as any).point;
                             if ('action' in point && point.action.actionUuid === actionUuid) {
+                                const existingTrigger = point.action.triggers.find((t: any) => t.triggerUuid === trigger.triggerUuid);
+                                if (!existingTrigger) {
                                     point.action.triggers.push(trigger);
                                     updatedEvent = JSON.parse(JSON.stringify(event));
+                                }
                                 return;
                             } else if ('actions' in point) {
                                 const action = point.actions.find((a: any) => a.actionUuid === actionUuid);
                                 if (action) {
+                                    const existingTrigger = action.triggers.find((t: any) => t.triggerUuid === trigger.triggerUuid);
+                                    if (!existingTrigger) {
                                         action.triggers.push(trigger);
                                         updatedEvent = JSON.parse(JSON.stringify(event));
+                                    }
                                     return;
                                 }
                             }
@@ -317,26 +349,35 @@ export const useProductStore = create<ProductsStore>()(
             return updatedEvent;
         },
 
-        removeTrigger: (triggerUuid) => {
+        removeTrigger: (productId, triggerUuid) => {
             let updatedEvent: EventsSchema | undefined;
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             for (const point of (event as ConveyorEventSchema).points) {
                                 if (point.action && 'triggers' in point.action) {
+                                    const Trigger = point.action.triggers.find(t => t.triggerUuid === triggerUuid);
+                                    if (Trigger) {
                                         point.action.triggers = point.action.triggers.filter(t => t.triggerUuid !== triggerUuid);
                                         updatedEvent = JSON.parse(JSON.stringify(event));
                                     }
                                 }
+                            }
                         } else if ('point' in event) {
                             const point = (event as any).point;
                             if ('action' in point && 'triggers' in point.action) {
+                                const Trigger = point.action.triggers.find((t: any) => t.triggerUuid === triggerUuid);
+                                if (Trigger) {
                                     point.action.triggers = point.action.triggers.filter((t: any) => t.triggerUuid !== triggerUuid);
                                     updatedEvent = JSON.parse(JSON.stringify(event));
+                                }
                             } else if ('actions' in point) {
                                 for (const action of point.actions) {
                                     if ('triggers' in action) {
+                                        const Trigger = action.triggers.find((t: any) => t.triggerUuid === triggerUuid);
+                                        if (Trigger) {
                                             action.triggers = action.triggers.filter((t: any) => t.triggerUuid !== triggerUuid);
                                             updatedEvent = JSON.parse(JSON.stringify(event));
                                         }
@@ -345,13 +386,15 @@ export const useProductStore = create<ProductsStore>()(
                             }
                         }
                     }
+                }
             });
             return updatedEvent;
         },
 
-        updateTrigger: (triggerUuid, updates) => {
+        updateTrigger: (productId, triggerUuid, updates) => {
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             for (const point of (event as ConveyorEventSchema).points) {
@@ -398,10 +441,11 @@ export const useProductStore = create<ProductsStore>()(
             });
         },
 
-        renameAction: (actionUuid, newName) => {
+        renameAction: (productId, actionUuid, newName) => {
             let updatedEvent: EventsSchema | undefined;
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             for (const point of (event as ConveyorEventSchema).points) {
@@ -432,9 +476,10 @@ export const useProductStore = create<ProductsStore>()(
             return updatedEvent;
         },
 
-        renameTrigger: (triggerUuid, newName) => {
+        renameTrigger: (productId, triggerUuid, newName) => {
             set((state) => {
-                for (const product of state.products) {
+                const product = state.products.find(p => p.productId === productId);
+                if (product) {
                     for (const event of product.eventDatas) {
                         if ('points' in event) {
                             for (const point of (event as ConveyorEventSchema).points) {

app/src/store/simulation/useStorageUnitStore.ts

@@ -4,26 +4,22 @@ import { immer } from 'zustand/middleware/immer';
 interface StorageUnitStore {
     storageUnits: StorageUnitStatus[];
 
-    // Actions
     addStorageUnit: (productId: string, storageUnit: StorageEventSchema) => void;
     removeStorageUnit: (modelUuid: string) => void;
     updateStorageUnit: (
         modelUuid: string,
         updates: Partial<Omit<StorageUnitStatus, 'modelUuid' | 'productId'>>
     ) => void;
+    clearStorageUnits: () => void;
 
-    // Status updates
     setStorageUnitActive: (modelUuid: string, isActive: boolean) => void;
     setStorageUnitState: (modelUuid: string, newState: StorageUnitStatus['state']) => void;
 
-    // Load updates
     updateStorageUnitLoad: (modelUuid: string, incrementBy: number) => void;
 
-    // Time tracking
     incrementActiveTime: (modelUuid: string, incrementBy: number) => void;
     incrementIdleTime: (modelUuid: string, incrementBy: number) => void;
 
-    // Helpers
     getStorageUnitById: (modelUuid: string) => StorageUnitStatus | undefined;
     getStorageUnitsByProduct: (productId: string) => StorageUnitStatus[];
     getStorageUnitsBystate: (state: string) => StorageUnitStatus[];
@@ -37,9 +33,10 @@ export const useStorageUnitStore = create<StorageUnitStore>()(
     immer((set, get) => ({
         storageUnits: [],
 
-        // Actions
         addStorageUnit: (productId, storageUnit) => {
             set((state) => {
+                const exists = state.storageUnits.some(s => s.modelUuid === storageUnit.modelUuid);
+                if (!exists) {
                     state.storageUnits.push({
                         ...storageUnit,
                         productId,
@@ -49,6 +46,7 @@ export const useStorageUnitStore = create<StorageUnitStore>()(
                         currentLoad: 0,
                         state: 'idle',
                     });
+                }
             });
         },
 
@@ -67,7 +65,12 @@ export const useStorageUnitStore = create<StorageUnitStore>()(
             });
         },
 
-        // Status updates
+        clearStorageUnits: () => {
+            set(() => ({
+                storageUnits: [],
+            }));
+        },
+
         setStorageUnitActive: (modelUuid, isActive) => {
             set((state) => {
                 const unit = state.storageUnits.find(s => s.modelUuid === modelUuid);
@@ -86,7 +89,6 @@ export const useStorageUnitStore = create<StorageUnitStore>()(
             });
         },
 
-        // Load updates
         updateStorageUnitLoad: (modelUuid, incrementBy) => {
             set((state) => {
                 const unit = state.storageUnits.find(s => s.modelUuid === modelUuid);
@@ -96,7 +98,6 @@ export const useStorageUnitStore = create<StorageUnitStore>()(
             });
         },
 
-        // Time tracking
         incrementActiveTime: (modelUuid, incrementBy) => {
             set((state) => {
                 const unit = state.storageUnits.find(s => s.modelUuid === modelUuid);
@@ -115,7 +116,6 @@ export const useStorageUnitStore = create<StorageUnitStore>()(
             });
         },
 
-        // Helpers
         getStorageUnitById: (modelUuid) => {
             return get().storageUnits.find(s => s.modelUuid === modelUuid);
         },

app/src/store/simulation/useVehicleStore.ts

@@ -20,6 +20,7 @@ interface VehiclesStore {
         modelUuid: string,
         updates: Partial<Omit<VehicleStatus, 'modelUuid' | 'productId'>>
     ) => void;
+    clearvehicles: () => void;
 
     setVehicleActive: (modelUuid: string, isActive: boolean) => void;
     updateSteeringAngle: (modelUuid: string, steeringAngle: number) => void;
@@ -41,6 +42,8 @@ export const useVehicleStore = create<VehiclesStore>()(
 
         addVehicle: (productId, event) => {
             set((state) => {
+                const exists = state.vehicles.some(v => v.modelUuid === event.modelUuid);
+                if (!exists) {
                     state.vehicles.push({
                         ...event,
                         productId,
@@ -50,6 +53,7 @@ export const useVehicleStore = create<VehiclesStore>()(
                         currentLoad: 0,
                         distanceTraveled: 0,
                     });
+                }
             });
         },
 
@@ -68,6 +72,12 @@ export const useVehicleStore = create<VehiclesStore>()(
             });
         },
 
+        clearvehicles: () => {
+            set((state) => {
+                state.vehicles = [];
+            });
+        },
+
         setVehicleActive: (modelUuid, isActive) => {
             set((state) => {
                 const vehicle = state.vehicles.find(v => v.modelUuid === modelUuid);

app/src/types/simulationTypes.d.ts

@@ -88,6 +88,7 @@ interface StoragePointSchema {
         actionType: "store";
         materials: { materialName: string; materialId: string; }[];
         storageCapacity: number;
+        triggers: TriggerSchema[];
     };
 }
 
@@ -143,6 +144,10 @@ interface MachineStatus extends MachineEventSchema {
     isActive: boolean;
     idleTime: number;
     activeTime: number;
+    currentAction?: {
+        actionUuid: string;
+        actionName: string;
+    };
 }
 
 interface ArmBotStatus extends RoboticArmEventSchema {