feat: Update simulation stores and types to enhance robotic arm and vehicle handling

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

@@ -257,8 +257,8 @@ async function handleModelLoad(
                             actionName: "Pick and Place",
                             actionType: "pickAndPlace",
                             process: {
-                                startPoint: "start-point-uuid",
+                                startPoint: [0, 0, 0],
-                                endPoint: "end-point-uuid"
+                                endPoint: [0, 0, 0]
                             },
                             triggers: []
                         }

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

@@ -16,11 +16,11 @@ import addAssetModel from "../geomentries/assets/addAssetModel";
 import { getFloorAssets } from "../../../services/factoryBuilder/assest/floorAsset/getFloorItemsApi";
 import useModuleStore from "../../../store/useModuleStore";
 // import { retrieveGLTF } from "../../../utils/indexDB/idbUtils";
+import { useEventsStore } from "../../../store/simulation/useEventsStore";
+
 const assetManagerWorker = new Worker(new URL("../../../services/factoryBuilder/webWorkers/assetManagerWorker.js", import.meta.url));
 const gltfLoaderWorker = new Worker(new URL("../../../services/factoryBuilder/webWorkers/gltfLoaderWorker.js", import.meta.url));
 
-import { useEventsStore } from "../../../store/simulation/useEventsStore";
-
 const FloorItemsGroup = ({ itemsGroup, hoveredDeletableFloorItem, AttachedObject, floorGroup, tempLoader, isTempLoader, plane, }: any) => {
     const state: Types.ThreeState = useThree();
     const { raycaster, controls }: any = state;

app/src/store/simulation/useArmBotStore.ts

@@ -1,17 +1,6 @@
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
 
-interface ArmBotStatus extends RoboticArmEventSchema {
-    productId: string;
-    isActive: boolean;
-    idleTime: number;
-    activeTime: number;
-    currentAction?: {
-        actionUuid: string;
-        actionName: string;
-    };
-}
-
 interface ArmBotStore {
     armBots: ArmBotStatus[];
 
@@ -22,9 +11,11 @@ interface ArmBotStore {
         updates: Partial<Omit<ArmBotStatus, 'modelUuid' | 'productId'>>
     ) => void;
 
-    startAction: (modelUuid: string, actionUuid: string) => void;
+    addCurrentAction: (modelUuid: string, actionUuid: string) => void;
-    completeAction: (modelUuid: string) => void;
+    removeCurrentAction: (modelUuid: string) => void;
-    cancelAction: (modelUuid: string) => void;
+
+    addAction: (modelUuid: string, action: RoboticArmPointSchema['actions'][number]) => void;
+    removeAction: (modelUuid: string, actionUuid: string) => void;
 
     setArmBotActive: (modelUuid: string, isActive: boolean) => void;
 
@@ -71,7 +62,7 @@ export const useArmBotStore = create<ArmBotStore>()(
             });
         },
 
-        startAction: (modelUuid, actionUuid) => {
+        addCurrentAction: (modelUuid, actionUuid) => {
             set((state) => {
                 const armBot = state.armBots.find(a => a.modelUuid === modelUuid);
                 if (armBot) {
@@ -87,22 +78,30 @@ export const useArmBotStore = create<ArmBotStore>()(
             });
         },
 
-        completeAction: (modelUuid) => {
+        removeCurrentAction: (modelUuid) => {
             set((state) => {
                 const armBot = state.armBots.find(a => a.modelUuid === modelUuid);
-                if (armBot && armBot.currentAction) {
+                if (armBot) {
                     armBot.currentAction = undefined;
                     armBot.isActive = false;
                 }
             });
         },
 
-        cancelAction: (modelUuid) => {
+        addAction: (modelUuid, action) => {
             set((state) => {
                 const armBot = state.armBots.find(a => a.modelUuid === modelUuid);
                 if (armBot) {
-                    armBot.currentAction = undefined;
+                    armBot.point.actions.push(action);
-                    armBot.isActive = false;
+                }
+            });
+        },
+
+        removeAction: (modelUuid, actionUuid) => {
+            set((state) => {
+                const armBot = state.armBots.find(a => a.modelUuid === modelUuid);
+                if (armBot) {
+                    armBot.point.actions = armBot.point.actions.filter(a => a.actionUuid !== actionUuid);
                 }
             });
         },

app/src/store/simulation/useConveyorStore.ts

@@ -1,13 +1,6 @@
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
 
-interface ConveyorStatus extends ConveyorEventSchema {
-    productId: string;
-    isActive: boolean;
-    idleTime: number;
-    activeTime: number;
-}
-
 interface ConveyorStore {
     conveyors: ConveyorStatus[];
 

app/src/store/simulation/useMachineStore.ts

@@ -1,13 +1,6 @@
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
 
-interface MachineStatus extends MachineEventSchema {
-    productId: string;
-    isActive: boolean;
-    idleTime: number;
-    activeTime: number;
-}
-
 interface MachineStore {
     machines: MachineStatus[];
 

app/src/store/simulation/useStorageUnitStore.ts

@@ -1,14 +1,6 @@
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
 
-interface StorageUnitStatus extends StorageEventSchema {
-    productId: string;
-    isActive: boolean;
-    idleTime: number;
-    activeTime: number;
-    currentLoad: number;
-}
-
 interface StorageUnitStore {
     storageUnits: StorageUnitStatus[];
 

app/src/store/simulation/useVehicleStore.ts

@@ -21,7 +21,8 @@ interface VehiclesStore {
     ) => void;
 
     setVehicleActive: (modelUuid: string, isActive: boolean) => void;
-    updateVehicleLoad: (modelUuid: string, load: number) => void;
+    incrementVehicleLoad: (modelUuid: string, incrementBy: number) => void;
+    decrementVehicleLoad: (modelUuid: string, decrementBy: number) => void;
     setVehicleState: (modelUuid: string, newState: VehicleStatus['state']) => void;
     incrementActiveTime: (modelUuid: string, incrementBy: number) => void;
     incrementIdleTime: (modelUuid: string, incrementBy: number) => void;
@@ -74,11 +75,20 @@ export const useVehicleStore = create<VehiclesStore>()(
             });
         },
 
-        updateVehicleLoad: (modelUuid, load) => {
+        incrementVehicleLoad: (modelUuid, incrementBy) => {
             set((state) => {
                 const vehicle = state.vehicles.find(v => v.modelUuid === modelUuid);
                 if (vehicle) {
-                    vehicle.currentLoad = load;
+                    vehicle.currentLoad += incrementBy;
+                }
+            });
+        },
+
+        decrementVehicleLoad: (modelUuid, decrementBy) => {
+            set((state) => {
+                const vehicle = state.vehicles.find(v => v.modelUuid === modelUuid);
+                if (vehicle) {
+                    vehicle.currentLoad = decrementBy;
                 }
             });
         },

app/src/types/simulationTypes.d.ts

@@ -59,7 +59,7 @@ interface RoboticArmPointSchema {
         actionUuid: string;
         actionName: string;
         actionType: "pickAndPlace";
-        process: { startPoint: string; endPoint: string };
+        process: { startPoint: [number, number, number]; endPoint: [number, number, number] };
         triggers: TriggerSchema[];
     }[];
 }
@@ -127,6 +127,32 @@ type productsSchema = {
     eventsData: EventsSchema[];
 }[]
 
+
+interface ConveyorStatus extends ConveyorEventSchema {
+    productId: string;
+    isActive: boolean;
+    idleTime: number;
+    activeTime: number;
+}
+
+interface MachineStatus extends MachineEventSchema {
+    productId: string;
+    isActive: boolean;
+    idleTime: number;
+    activeTime: number;
+}
+
+interface ArmBotStatus extends RoboticArmEventSchema {
+    productId: string;
+    isActive: boolean;
+    idleTime: number;
+    activeTime: number;
+    currentAction?: {
+        actionUuid: string;
+        actionName: string;
+    };
+}
+
 interface VehicleStatus extends VehicleEventSchema {
     productId: string;
     isActive: boolean;
@@ -135,3 +161,11 @@ interface VehicleStatus extends VehicleEventSchema {
     currentLoad: number;
     distanceTraveled: number;
 }
+
+interface StorageUnitStatus extends StorageEventSchema {
+    productId: string;
+    isActive: boolean;
+    idleTime: number;
+    activeTime: number;
+    currentLoad: number;
+}