Merge remote-tracking branch 'origin/v2' into v2-ui

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

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

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

@@ -14,7 +14,7 @@ function RoboticArmMechanics() {
     const [activeOption, setActiveOption] = useState<"default" | "pickAndPlace">("default");
     const [selectedPointData, setSelectedPointData] = useState<RoboticArmPointSchema | undefined>();
     const { selectedEventData } = useSelectedEventData();
-    const { getPointByUuid, getEventByModelUuid, updateEvent, updateAction, addAction, removeAction } = useProductStore();
+    const { getPointByUuid, getEventByModelUuid, getActionByUuid, updateEvent, updateAction, addAction, removeAction } = useProductStore();
     const { selectedProduct } = useSelectedProduct();
     const { selectedAction, setSelectedAction, clearSelectedAction } = useSelectedAction();
 
@@ -28,20 +28,28 @@ function RoboticArmMechanics() {
                 selectedEventData.data.modelUuid,
                 selectedEventData.selectedPoint
             ) as RoboticArmPointSchema | undefined;
+            const action = getActionByUuid(selectedProduct.productId, selectedAction.actionId) as RoboticArmPointSchema["actions"][0] | undefined;
+            if (action) {
                 if (point?.actions) {
                     setSelectedPointData(point);
+                    if (point.actions.length > 0 && action) {
+                        setActiveOption(action.actionType as "default" | "pickAndPlace");
+                        setSelectedAction(selectedAction.actionId, selectedAction.actionName);
+                    }
+                }
+            } else {
+                if (point?.actions) {
+                    setSelectedPointData(point);
+                    if (point.actions.length > 0) {
                         setActiveOption(point.actions[0].actionType as "default" | "pickAndPlace");
-                if (point.actions.length > 0 && !selectedAction.actionId) {
+                        setSelectedAction(point.actions[0].actionUuid, point.actions[0].actionName);
-                    setSelectedAction(
+                    }
-                        point.actions[0].actionUuid,
-                        point.actions[0].actionName
-                    );
                 }
             }
         } else {
             clearSelectedAction();
         }
-    }, [clearSelectedAction, getPointByUuid, selectedAction.actionId, selectedEventData, selectedProduct, setSelectedAction,]);
+    }, [selectedAction, selectedEventData, selectedProduct]);
 
     const updateBackend = (
         productName: string,
@@ -192,9 +200,8 @@ function RoboticArmMechanics() {
             );
         }
 
-        const newActions = selectedPointData.actions.filter(
+        const index = selectedPointData.actions.findIndex(a => a.actionUuid === actionUuid);
-            (a: any) => a.actionUuid !== actionUuid
+        const newActions = selectedPointData.actions.filter(a => a.actionUuid !== actionUuid);
-        );
 
         const updatedPoint = {
             ...selectedPointData,
@@ -203,8 +210,9 @@ function RoboticArmMechanics() {
         setSelectedPointData(updatedPoint);
 
         if (selectedAction.actionId === actionUuid) {
-            if (newActions.length > 0) {
+            const nextAction = newActions[index] || newActions[index - 1];
-                setSelectedAction(newActions[0].actionUuid, newActions[0].actionName);
+            if (nextAction) {
+                setSelectedAction(nextAction.actionUuid, nextAction.actionName);
             } else {
                 clearSelectedAction();
             }

app/src/components/layout/sidebarRight/properties/eventProperties/trigger/Trigger.tsx

@@ -20,7 +20,7 @@ type TriggerProps = {
 const Trigger = ({ selectedPointData, type }: TriggerProps) => {
     const [currentAction, setCurrentAction] = useState<string | undefined>();
     const { selectedProduct } = useSelectedProduct();
-    const { getActionByUuid, addTrigger, removeTrigger, updateTrigger, renameTrigger, getProductById } = useProductStore();
+    const { getActionByUuid, getEventByModelUuid, getPointByUuid, getTriggerByUuid, addTrigger, removeTrigger, updateTrigger, renameTrigger, getProductById } = useProductStore();
     const [triggers, setTriggers] = useState<TriggerSchema[]>([]);
     const [selectedTrigger, setSelectedTrigger] = useState<TriggerSchema | undefined>();
     const [activeOption, setActiveOption] = useState<"onComplete" | "onStart" | "onStop" | "delay" | "onError">("onComplete");
@@ -43,7 +43,6 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
         setCurrentAction(actionUuid);
     }, [selectedPointData, selectedProduct, type]);
 
-
     const updateBackend = (
         productName: string,
         productId: string,
@@ -66,55 +65,32 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
         setSelectedTrigger(actionTriggers[0]);
     }, [currentAction, selectedProduct]);
 
-    const handleAddTrigger = () => {
+    const triggeredModel = useMemo(() => {
-        if (!selectedProduct || !currentAction) return;
+        if (!selectedProduct || !selectedTrigger?.triggeredAsset?.triggeredModel?.modelUuid) return undefined;
+        return getEventByModelUuid(selectedProduct.productId, selectedTrigger.triggeredAsset.triggeredModel.modelUuid);
+    }, [selectedProduct, selectedTrigger]);
 
-        const newTrigger: TriggerSchema = {
+    const triggeredPoint = useMemo(() => {
-            triggerUuid: THREE.MathUtils.generateUUID(),
+        if (!selectedProduct || !triggeredModel || !selectedTrigger?.triggeredAsset?.triggeredPoint?.pointUuid) return undefined;
-            triggerName: `New Trigger ${triggers.length + 1}`,
+        return getPointByUuid(
-            triggerType: activeOption,
+            selectedProduct.productId,
-            delay: 0,
+            triggeredModel.modelUuid,
-            triggeredAsset: null
+            selectedTrigger.triggeredAsset.triggeredPoint.pointUuid
-        };
+        );
+    }, [selectedProduct, triggeredModel, selectedTrigger]);
 
-        addTrigger(selectedProduct.productId, currentAction, newTrigger);
+    const triggeredAction = useMemo(() => {
-        setSelectedTrigger(newTrigger);
+        if (!selectedProduct || !selectedTrigger?.triggeredAsset?.triggeredAction?.actionUuid) return undefined;
-    };
+        return getActionByUuid(
-
+            selectedProduct.productId,
-    const handleRemoveTrigger = (triggerUuid: string) => {
+            selectedTrigger.triggeredAsset.triggeredAction.actionUuid
-        if (!selectedProduct) return;
+        );
-        removeTrigger(selectedProduct.productId, triggerUuid);
+    }, [selectedProduct, selectedTrigger]);
-        if (selectedTrigger?.triggerUuid === triggerUuid) {
-            const remainingTriggers = triggers.filter(t => t.triggerUuid !== triggerUuid);
-            setSelectedTrigger(remainingTriggers[0]);
-        }
-    };
-
-    const handleTriggerRename = (triggerUuid: string, newName: string) => {
-        if (!selectedProduct) return;
-        renameTrigger(selectedProduct.productId, triggerUuid, newName);
-    };
-
-    const handleTriggerTypeChange = (option: string) => {
-        if (!selectedTrigger || !selectedProduct) return;
-
-        const validTypes: Array<TriggerSchema['triggerType']> = ["onComplete", "onStart", "onStop", "delay", "onError"];
-        if (!validTypes.includes(option as TriggerSchema['triggerType'])) return;
-
-        setActiveOption(option as TriggerSchema['triggerType']);
-        updateTrigger(selectedProduct.productId, selectedTrigger.triggerUuid, {
-            triggerType: option as TriggerSchema['triggerType']
-        });
-    };
-
-    const triggeredModel = selectedTrigger?.triggeredAsset?.triggeredModel || { modelName: "Select Model", modelUuid: "" };
-    const triggeredPoint = selectedTrigger?.triggeredAsset?.triggeredPoint || { pointName: "Select Point", pointUuid: "" };
-    const triggeredAction = selectedTrigger?.triggeredAsset?.triggeredAction || { actionName: "Select Action", actionUuid: "" };
 
     const modelOptions = getProductById(selectedProduct.productId)?.eventDatas || [];
 
     const pointOptions: PointsScheme[] = useMemo(() => {
-        if (!triggeredModel.modelUuid) return [];
+        if (!triggeredModel) return [];
 
         const model = modelOptions.find(m => m.modelUuid === triggeredModel.modelUuid);
         if (!model) return [];
@@ -125,11 +101,11 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
             return [(model as VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema).point];
         }
         return [];
-    }, [triggeredModel.modelUuid, modelOptions]);
+    }, [triggeredModel, modelOptions]);
 
     const actionOptions: any = useMemo(() => {
-        if (!triggeredPoint.pointUuid) return [];
+        if (!triggeredPoint) return [];
-        const point = pointOptions.find((p) => p.uuid === triggeredPoint.pointUuid);
+        const point = pointOptions.find((p) => p.uuid === triggeredPoint.uuid);
         if (!point) return [];
 
         if ('action' in point) {
@@ -140,7 +116,7 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
             return typedPoint.actions;
         }
         return [];
-    }, [triggeredPoint.pointUuid, pointOptions]);
+    }, [triggeredPoint, pointOptions]);
 
     const handleModelSelect = (option: string, triggerUuid: string) => {
         if (!selectedProduct) return;
@@ -160,6 +136,9 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
         });
 
         if (event) {
+            const updatedTrigger = getTriggerByUuid(selectedProduct.productId, triggerUuid);
+            setSelectedTrigger(updatedTrigger);
+
             updateBackend(
                 selectedProduct.productName,
                 selectedProduct.productId,
@@ -172,8 +151,7 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
     const handlePointSelect = (option: string, triggerUuid: string) => {
         if (!selectedProduct || !selectedTrigger) return;
 
-        const pointUuid = pointOptions.find(p => `Point ${p.uuid.slice(0, 5)}` === option)?.uuid;
+        const pointUuid = pointOptions.find(p => `Point ${p.uuid.slice(0, 4)}` === option)?.uuid;
-
         if (!pointUuid) return;
 
         if (selectedTrigger.triggeredAsset?.triggeredModel) {
@@ -189,6 +167,9 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
             });
 
             if (event) {
+                const updatedTrigger = getTriggerByUuid(selectedProduct.productId, triggerUuid);
+                setSelectedTrigger(updatedTrigger);
+
                 updateBackend(
                     selectedProduct.productName,
                     selectedProduct.productId,
@@ -199,6 +180,7 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
         }
     };
 
+
     const handleActionSelect = (option: string, triggerUuid: string) => {
         if (!selectedProduct || !selectedTrigger) return;
 
@@ -228,6 +210,94 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
         }
     };
 
+    const handleAddTrigger = () => {
+        if (!selectedProduct || !currentAction) return;
+
+        const newTrigger: TriggerSchema = {
+            triggerUuid: THREE.MathUtils.generateUUID(),
+            triggerName: `New Trigger ${triggers.length + 1}`,
+            triggerType: activeOption,
+            delay: 0,
+            triggeredAsset: null
+        };
+
+        const event = addTrigger(selectedProduct.productId, currentAction, newTrigger);
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+
+        const updatedAction = getActionByUuid(selectedProduct.productId, currentAction);
+        const updatedTriggers = updatedAction?.triggers || [];
+
+        setTriggers(updatedTriggers);
+        setSelectedTrigger(newTrigger);
+    };
+
+    const handleRemoveTrigger = (triggerUuid: string) => {
+        if (!selectedProduct || !currentAction) return;
+
+        const event = removeTrigger(selectedProduct.productId, triggerUuid);
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+
+        const index = triggers.findIndex(t => t.triggerUuid === triggerUuid);
+        const newTriggers = triggers.filter(t => t.triggerUuid !== triggerUuid);
+        setTriggers(newTriggers);
+
+        if (selectedTrigger?.triggerUuid === triggerUuid) {
+            const nextTrigger = newTriggers[index] || newTriggers[index - 1];
+            setSelectedTrigger(nextTrigger);
+        }
+    };
+
+    const handleTriggerRename = (triggerUuid: string, newName: string) => {
+        if (!selectedProduct) return;
+        const event = renameTrigger(selectedProduct.productId, triggerUuid, newName);
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+    };
+
+    const handleTriggerTypeChange = (option: string) => {
+        if (!selectedTrigger || !selectedProduct) return;
+
+        const validTypes: Array<TriggerSchema['triggerType']> = ["onComplete", "onStart", "onStop", "delay", "onError"];
+        if (!validTypes.includes(option as TriggerSchema['triggerType'])) return;
+
+        setActiveOption(option as TriggerSchema['triggerType']);
+        const event = updateTrigger(selectedProduct.productId, selectedTrigger.triggerUuid, {
+            triggerType: option as TriggerSchema['triggerType']
+        });
+
+        if (event) {
+            updateBackend(
+                selectedProduct.productName,
+                selectedProduct.productId,
+                organization,
+                event
+            );
+        }
+    };
+
     return (
         <div className="trigger-wrapper">
             <div className="header">
@@ -296,19 +366,19 @@ const Trigger = ({ selectedPointData, type }: TriggerProps) => {
                         <div className="trigger-options">
                             <LabledDropdown
                                 label="Triggered Object"
-                                defaultOption={triggeredModel.modelName}
+                                defaultOption={triggeredModel?.modelName || ""}
                                 options={[...modelOptions.map((option) => (option.modelName))]}
                                 onSelect={(option) => { handleModelSelect(option, selectedTrigger.triggerUuid) }}
                             />
                             <LabledDropdown
                                 label="Triggered Point"
-                                defaultOption={triggeredPoint.pointName}
+                                defaultOption={triggeredPoint?.uuid ? `Point ${triggeredPoint?.uuid.slice(0, 4)}` : ''}
-                                options={[...pointOptions.map((option) => (`Point ${option.uuid.slice(0, 5)}`))]}
+                                options={[...pointOptions.map((option) => (`Point ${option.uuid.slice(0, 4)}`))]}
                                 onSelect={(option) => { handlePointSelect(option, selectedTrigger.triggerUuid) }}
                             />
                             <LabledDropdown
                                 label="Triggered Action"
-                                defaultOption={triggeredAction.actionName}
+                                defaultOption={triggeredAction?.actionName || ''}
                                 options={[...actionOptions.map((option: any) => (option.actionName))]}
                                 onSelect={(option) => { handleActionSelect(option, selectedTrigger.triggerUuid) }}
                             />

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

@@ -228,7 +228,7 @@ function processLoadedModel(
                     rotation: [point.rotation[0], point.rotation[1], point.rotation[2]],
                     action: {
                         actionUuid: THREE.MathUtils.generateUUID(),
-                        actionName: `Action ${index + 1}`,
+                        actionName: `Action 1`,
                         actionType: 'default',
                         material: 'Default material',
                         delay: 0,

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

@@ -173,7 +173,7 @@ const CopyPasteControls = ({ itemsGroupRef, copiedObjects, setCopiedObjects, pas
                                 rotation: [point.rotation[0], point.rotation[1], point.rotation[2]],
                                 action: {
                                     actionUuid: THREE.MathUtils.generateUUID(),
-                                    actionName: `Action ${index}`,
+                                    actionName: `Action 1`,
                                     actionType: 'default',
                                     material: 'Default Material',
                                     delay: 0,

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

@@ -151,7 +151,7 @@ const DuplicationControls = ({ itemsGroupRef, duplicatedObjects, setDuplicatedOb
                                 rotation: [point.rotation[0], point.rotation[1], point.rotation[2]],
                                 action: {
                                     actionUuid: THREE.MathUtils.generateUUID(),
-                                    actionName: `Action ${index}`,
+                                    actionName: `Action 1`,
                                     actionType: 'default',
                                     material: 'Default Material',
                                     delay: 0,

app/src/modules/simulation/events/points/creator/pointsCreator.tsx

@@ -15,21 +15,13 @@ import { useThree } from "@react-three/fiber";
 function PointsCreator() {
     const { gl, raycaster, scene, pointer, camera } = useThree();
     const { subModule } = useSubModuleStore();
-  const { events, updatePoint, getPointByUuid, getEventByModelUuid } =
+    const { events, updatePoint, getPointByUuid, getEventByModelUuid } = useEventsStore();
-    useEventsStore();
     const { activeModule } = useModuleStore();
     const transformRef = useRef<any>(null);
-  const [transformMode, setTransformMode] = useState<
+    const [transformMode, setTransformMode] = useState<"translate" | "rotate" | null>(null);
-    "translate" | "rotate" | null
-  >(null);
     const sphereRefs = useRef<{ [key: string]: THREE.Mesh }>({});
-  const {
+    const { selectedEventSphere, setSelectedEventSphere, clearSelectedEventSphere, } = useSelectedEventSphere();
-    selectedEventSphere,
+    const { selectedEventData, setSelectedEventData, clearSelectedEventData } = useSelectedEventData();
-    setSelectedEventSphere,
-    clearSelectedEventSphere,
-  } = useSelectedEventSphere();
-  const { setSelectedEventData, clearSelectedEventData } =
-    useSelectedEventData();
 
   useEffect(() => {
     if (selectedEventSphere) {
@@ -136,16 +128,16 @@ function PointsCreator() {
             {activeModule === "simulation" && (
                 <>
                     <group name="EventPointsGroup">
-            {events.map((event, index) => {
+                        {events.map((event, i) => {
                             if (event.type === "transfer") {
                                 return (
                                     <group
-                    key={`${index}-${event.modelUuid}`}
+                                        key={i}
-                    position={new THREE.Vector3(...event.position)}
+                                        position={event.position}
+                                        rotation={event.rotation}
                                     >
-                    {event.points.map((point, i) => (
+                                        {event.points.map((point, j) => (
                                             <mesh
-                        key={`${i}-${point.uuid}`}
                                                 name="Event-Sphere"
                                                 uuid={point.uuid}
                                                 ref={(el) => (sphereRefs.current[point.uuid] = el!)}
@@ -155,6 +147,7 @@ function PointsCreator() {
                                                         sphereRefs.current[point.uuid]
                                                     );
                                                 }}
+                                                key={`${i}-${j}`}
                                                 position={new THREE.Vector3(...point.position)}
                                                 userData={{
                                                     modelUuid: event.modelUuid,
@@ -170,8 +163,9 @@ function PointsCreator() {
                             } else if (event.type === "vehicle") {
                                 return (
                                     <group
-                    key={`${index}-${event.modelUuid}`}
+                                        key={i}
-                    position={new THREE.Vector3(...event.position)}
+                                        position={event.position}
+                                        rotation={event.rotation}
                                     >
                                         <mesh
                                             name="Event-Sphere"
@@ -197,8 +191,9 @@ function PointsCreator() {
                             } else if (event.type === "roboticArm") {
                                 return (
                                     <group
-                    key={`${index}-${event.modelUuid}`}
+                                        key={i}
-                    position={new THREE.Vector3(...event.position)}
+                                        position={event.position}
+                                        rotation={event.rotation}
                                     >
                                         <mesh
                                             name="Event-Sphere"
@@ -224,8 +219,9 @@ function PointsCreator() {
                             } else if (event.type === "machine") {
                                 return (
                                     <group
-                    key={`${index}-${event.modelUuid}`}
+                                        key={i}
-                    position={new THREE.Vector3(...event.position)}
+                                        position={event.position}
+                                        rotation={event.rotation}
                                     >
                                         <mesh
                                             name="Event-Sphere"

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

@@ -5,10 +5,14 @@ import { useSelectedProduct } from '../../../store/simulation/useSimulationStore
 import AddOrRemoveEventsInProducts from './events/addOrRemoveEventsInProducts';
 import { upsertProductOrEventApi } from '../../../services/simulation/UpsertProductOrEventApi';
 import { getAllProductsApi } from '../../../services/simulation/getallProductsApi';
+import { useVehicleStore } from '../../../store/simulation/useVehicleStore';
+import { useArmBotStore } from '../../../store/simulation/useArmBotStore';
 
 function Products() {
-    const { addProduct, setProducts } = useProductStore();
+    const { products, getProductById, addProduct, setProducts } = useProductStore();
-    const { setSelectedProduct } = useSelectedProduct();
+    const { selectedProduct, setSelectedProduct } = useSelectedProduct();
+    const { addVehicle, clearvehicles } = useVehicleStore();
+    const { addArmBot, clearArmBots } = useArmBotStore();
 
     useEffect(() => {
         const email = localStorage.getItem('email')
@@ -27,6 +31,34 @@ function Products() {
         })
     }, [])
 
+    useEffect(() => {
+        if (selectedProduct.productId) {
+            const product = getProductById(selectedProduct.productId);
+            if (product) {
+                clearvehicles();
+                product.eventDatas.forEach(events => {
+                    if (events.type === 'vehicle') {
+                        addVehicle(selectedProduct.productId, events);
+                    }
+                });
+            }
+        }
+    }, [selectedProduct, products]);
+
+    useEffect(() => {
+        if (selectedProduct.productId) {
+            const product = getProductById(selectedProduct.productId);
+            if (product) {
+                clearArmBots();
+                product.eventDatas.forEach(events => {
+                    if (events.type === 'roboticArm') {
+                        addArmBot(selectedProduct.productId, events);
+                    }
+                });
+            }
+        }
+    }, [selectedProduct, products]);
+
     return (
         <>
 

app/src/modules/simulation/roboticArm/instances/armInstance/roboticArmInstance.tsx

@@ -147,8 +147,7 @@ function RoboticArmInstance({ armBot }: { armBot: ArmBotStatus }) {
             else if (armBot && !armBot.isActive && armBot.state === "idle" && currentPhase === "rest" && !armBot.currentAction) {
                 logStatus(armBot.modelUuid, "Waiting to trigger CurrentAction")
                 const timeoutId = setTimeout(() => {
-                    addCurrentAction(armBot.modelUuid, selectedAction?.actionId);
+                    addCurrentAction(armBot.modelUuid, armBot.point.actions[0].actionUuid);
-                    console.log('selectedAction?.actionId: ', selectedAction?.actionId);
                 }, 3000);
                 return () => clearTimeout(timeoutId);
             }
@@ -159,7 +158,6 @@ function RoboticArmInstance({ armBot }: { armBot: ArmBotStatus }) {
                     setArmBotState(armBot.modelUuid, "running");
                     setCurrentPhase("rest-to-start");
                     let actiondata = getActionByUuid(selectedProduct.productId, selectedAction.actionId)
-                    console.log('actiondata: ', actiondata);
                     const startPoint = armBot.point.actions[0].process.startPoint;
                     if (startPoint) {
                         let curve = createCurveBetweenTwoPoints(restPosition, new THREE.Vector3(startPoint[0], startPoint[1], startPoint[2]));

app/src/modules/simulation/roboticArm/roboticArm.tsx

@@ -1,46 +1,27 @@
 import { useEffect } from "react";
 import RoboticArmInstances from "./instances/roboticArmInstances";
 import { useArmBotStore } from "../../../store/simulation/useArmBotStore";
-import { useSelectedEventData, useSelectedEventSphere, useSelectedProduct } from "../../../store/simulation/useSimulationStore";
+import { useSelectedEventData, useSelectedEventSphere } from "../../../store/simulation/useSimulationStore";
-import { useProductStore } from "../../../store/simulation/useProductStore";
-import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
 import ArmBotUI from "../ui/arm/armBotUI";
 
 function RoboticArm() {
-    const { armBots, addArmBot, clearArmBots } = useArmBotStore();
+    const { armBots } = useArmBotStore();
-    const { products, getProductById } = useProductStore();
-    const { selectedProduct } = useSelectedProduct();
     const { selectedEventSphere } = useSelectedEventSphere();
     const { selectedEventData } = useSelectedEventData();
-    const { isPlaying } = usePlayButtonStore();
-
-    useEffect(() => {
-        if (selectedProduct.productId) {
-            const product = getProductById(selectedProduct.productId);
-            if (product) {
-                clearArmBots();
-                product.eventDatas.forEach(events => {
-                    if (events.type === 'roboticArm') {
-                        addArmBot(selectedProduct.productId, events);
-                    }
-                });
-            }
-        }
-    }, [selectedProduct, products]);
 
     useEffect(() => {
+        // console.log('armBots: ', armBots);
     }, [armBots])
 
-    useEffect(() => {
-
-    }, [selectedEventData, selectedEventSphere, isPlaying]);
-
     return (
         <>
+
             <RoboticArmInstances />
+
             {selectedEventSphere && selectedEventData?.data.type === "roboticArm" &&
                 < ArmBotUI />
             }
+
         </>
     );
 }

app/src/modules/simulation/ui/arm/armBotUI.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useState } from 'react';
-import { useSelectedAction, useSelectedEventData, useSelectedProduct } from '../../../../store/simulation/useSimulationStore';
+import { useSelectedAction, useSelectedEventData, useSelectedEventSphere, useSelectedProduct } from '../../../../store/simulation/useSimulationStore';
 import { useGLTF } from '@react-three/drei';
 import { useThree } from '@react-three/fiber';
 import { useProductStore } from '../../../../store/simulation/useProductStore';
@@ -19,7 +19,7 @@ type Positions = {
 
 const ArmBotUI = () => {
     const { getEventByModelUuid, updateAction, getActionByUuid } = useProductStore();
-    const { selectedEventData } = useSelectedEventData();
+    const { selectedEventSphere } = useSelectedEventSphere();
     const { selectedProduct } = useSelectedProduct();
     const { scene } = useThree();
     const { selectedAction } = useSelectedAction();
@@ -50,14 +50,14 @@ const ArmBotUI = () => {
 
     // Fetch and setup selected ArmBot data
     useEffect(() => {
-        if (selectedEventData?.data.type === "roboticArm") {
+        if (selectedEventSphere) {
-            const selectedArmBot = getEventByModelUuid(selectedProduct.productId, selectedEventData.data.modelUuid);
+            const selectedArmBot = getEventByModelUuid(selectedProduct.productId, selectedEventSphere.userData.modelUuid);
 
             if (selectedArmBot?.type === "roboticArm") {
                 setSelectedArmBotData(selectedArmBot);
                 const defaultPositions = getDefaultPositions(selectedArmBot.modelUuid);
                 const matchingAction = getActionByUuid(selectedProduct.productId, selectedAction.actionId);
-                if (matchingAction) {
+                if (matchingAction && (matchingAction as RoboticArmPointSchema["actions"][0]).process) {
                     const startPoint = (matchingAction as RoboticArmPointSchema["actions"][0]).process.startPoint;
                     const pickPosition = (!startPoint || (Array.isArray(startPoint) && startPoint.every(v => v === 0)))
                         ? defaultPositions.pick
@@ -73,8 +73,7 @@ const ArmBotUI = () => {
                 }
             }
         }
-    }, [selectedEventData, selectedProduct, getEventByModelUuid, selectedAction]);
+    }, [selectedEventSphere, selectedProduct, getEventByModelUuid, selectedAction]);
-
 
     function getDefaultPositions(modelUuid: string): Positions {
         const modelData = getEventByModelUuid(selectedProduct.productId, modelUuid);
@@ -117,8 +116,8 @@ const ArmBotUI = () => {
         obj.getWorldPosition(newPosition);
         const worldPositionArray = newPosition.toArray() as [number, number, number];
 
-        if (selectedEventData?.data.type === "roboticArm") {
+        if (selectedEventSphere) {
-            const selectedArmBot = getEventByModelUuid(selectedProduct.productId, selectedEventData.data.modelUuid);
+            const selectedArmBot = getEventByModelUuid(selectedProduct.productId, selectedEventSphere.userData.modelUuid);
 
             const armBot = selectedArmBot?.modelUuid === modelUuid ? selectedArmBot : null;
             if (!armBot) return;

app/src/modules/simulation/vehicle/instances/animator/vehicleAnimator.tsx

@@ -15,7 +15,7 @@ interface VehicleAnimatorProps {
 }
 
 function VehicleAnimator({ path, handleCallBack, currentPhase, agvUuid, agvDetail, reset }: VehicleAnimatorProps) {
-    const { decrementVehicleLoad } = useVehicleStore();
+    const { decrementVehicleLoad, getVehicleById } = useVehicleStore();
     const { isPaused } = usePauseButtonStore();
     const { isPlaying } = usePlayButtonStore();
     const { speed } = useAnimationPlaySpeed();
@@ -34,7 +34,6 @@ function VehicleAnimator({ path, handleCallBack, currentPhase, agvUuid, agvDetai
     let coveredDistance = progressRef.current;
     let objectRotation = (agvDetail.point?.action?.pickUpPoint?.rotation || { x: 0, y: 0, z: 0 }) as { x: number; y: number; z: number } | undefined;
 
-
     useEffect(() => {
         if (currentPhase === 'stationed-pickup' && path.length > 0) {
             setCurrentPath(path);
@@ -69,9 +68,10 @@ function VehicleAnimator({ path, handleCallBack, currentPhase, agvUuid, agvDetai
             isPausedRef.current = false;
             pauseTimeRef.current = 0;
             const object = scene.getObjectByProperty('uuid', agvUuid);
-            if (object) {
+            const vehicle = getVehicleById(agvDetail.modelUuid);
-                object.position.set(agvDetail.position[0], agvDetail.position[1], agvDetail.position[2]);
+            if (object && vehicle) {
-                object.rotation.set(agvDetail.rotation[0], agvDetail.rotation[1], agvDetail.rotation[2]);
+                object.position.set(vehicle.position[0], vehicle.position[1], vehicle.position[2]);
+                object.rotation.set(vehicle.rotation[0], vehicle.rotation[1], vehicle.rotation[2]);
             }
         }
     }, [isReset, isPlaying])

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

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

app/src/store/simulation/useProductStore.ts

@@ -56,7 +56,7 @@ type ProductsStore = {
     // Renaming functions
     renameProduct: (productId: string, newName: string) => void;
     renameAction: (productId: string, actionUuid: string, newName: string) => EventsSchema | undefined;
-    renameTrigger: (productId: string, triggerUuid: string, newName: string) => void;
+    renameTrigger: (productId: string, triggerUuid: string, newName: string) => EventsSchema | undefined;
 
     // Helper functions
     getProductById: (productId: string) => { productName: string; productId: string; eventDatas: EventsSchema[] } | undefined;
@@ -482,6 +482,7 @@ export const useProductStore = create<ProductsStore>()(
         },
 
         renameTrigger: (productId, triggerUuid, newName) => {
+            let updatedEvent: EventsSchema | undefined;
             set((state) => {
                 const product = state.products.find(p => p.productId === productId);
                 if (product) {
@@ -492,6 +493,7 @@ export const useProductStore = create<ProductsStore>()(
                                     const trigger = point.action.triggers.find(t => t.triggerUuid === triggerUuid);
                                     if (trigger) {
                                         trigger.triggerName = newName;
+                                        updatedEvent = JSON.parse(JSON.stringify(event));
                                         return;
                                     }
                                 }
@@ -502,6 +504,7 @@ export const useProductStore = create<ProductsStore>()(
                                 const trigger = point.action.triggers.find((t: any) => t.triggerUuid === triggerUuid);
                                 if (trigger) {
                                     trigger.triggerName = newName;
+                                    updatedEvent = JSON.parse(JSON.stringify(event));
                                     return;
                                 }
                             } else if ('actions' in point) {
@@ -510,6 +513,7 @@ export const useProductStore = create<ProductsStore>()(
                                         const trigger = action.triggers.find((t: any) => t.triggerUuid === triggerUuid);
                                         if (trigger) {
                                             trigger.triggerName = newName;
+                                            updatedEvent = JSON.parse(JSON.stringify(event));
                                             return;
                                         }
                                     }
@@ -519,6 +523,7 @@ export const useProductStore = create<ProductsStore>()(
                     }
                 }
             });
+            return updatedEvent;
         },
 
         // Helper functions