feat: Add assembly action handling and UI components

- Implemented `useAssemblyHandler` to manage assembly actions for humans.
- Enhanced `useHumanActions` to include assembly action handling.
- Updated `HumanInstance` to support assembly processes and animations.
- Modified `HumanUi` to allow for assembly point configuration and rotation.
- Created `AssemblyAction` component for setting process time and material swap options.
- Updated simulation types to include assembly action properties.
- Adjusted existing action handlers to accommodate assembly actions alongside worker actions.
- Refactored `MaterialAnimator` and `VehicleAnimator` to manage attachment states and visibility based on load.
- Updated product store types to include human point actions.

app/src/modules/simulation/actions/human/actionHandler/useAssemblyHandler.ts

@@ -0,0 +1,36 @@
+import { useCallback } from "react";
+import { useSceneContext } from "../../../../scene/sceneContext";
+import { useProductContext } from "../../../products/productContext";
+
+export function useAssemblyHandler() {
+    const { materialStore, humanStore, productStore } = useSceneContext();
+    const { getMaterialById } = materialStore();
+    const { getModelUuidByActionUuid } = productStore();
+    const { selectedProductStore } = useProductContext();
+    const { selectedProduct } = selectedProductStore();
+    const { incrementHumanLoad, addCurrentMaterial } = humanStore();
+
+    const assemblyLogStatus = (materialUuid: string, status: string) => {
+        echo.info(`${materialUuid}, ${status}`);
+    }
+
+    const handleAssembly = useCallback((action: HumanAction, materialId?: string) => {
+        if (!action || action.actionType !== 'assembly' || !materialId) return;
+
+        const material = getMaterialById(materialId);
+        if (!material) return;
+
+        const modelUuid = getModelUuidByActionUuid(selectedProduct.productUuid, action.actionUuid);
+        if (!modelUuid) return;
+
+        incrementHumanLoad(modelUuid, 1);
+        addCurrentMaterial(modelUuid, material.materialType, material.materialId);
+
+        assemblyLogStatus(material.materialName, `performing assembly action`);
+
+    }, [getMaterialById]);
+
+    return {
+        handleAssembly,
+    };
+}

app/src/modules/simulation/actions/human/useHumanActions.ts

@@ -1,13 +1,19 @@
 import { useEffect, useCallback } from 'react';
 import { useWorkerHandler } from './actionHandler/useWorkerHandler';
+import { useAssemblyHandler } from './actionHandler/useAssemblyHandler';
 
 export function useHumanActions() {
     const { handleWorker } = useWorkerHandler();
+    const { handleAssembly } = useAssemblyHandler();
 
     const handleWorkerAction = useCallback((action: HumanAction, materialId: string) => {
         handleWorker(action, materialId);
     }, [handleWorker]);
 
+    const handleAssemblyAction = useCallback((action: HumanAction, materialId: string) => {
+        handleAssembly(action, materialId);
+    }, [handleAssembly]);
+
     const handleHumanAction = useCallback((action: HumanAction, materialId: string) => {
         if (!action) return;
 
@@ -15,10 +21,13 @@ export function useHumanActions() {
             case 'worker':
                 handleWorkerAction(action, materialId);
                 break;
+            case 'assembly':
+                handleAssemblyAction(action, materialId);
+                break;
             default:
                 console.warn(`Unknown Human action type: ${action.actionType}`);
         }
-    }, [handleWorkerAction]);
+    }, [handleWorkerAction, handleAssemblyAction]);
 
     const cleanup = useCallback(() => {
     }, []);

app/src/modules/simulation/actions/useActionHandler.ts

@@ -39,7 +39,7 @@ export function useActionHandler() {
                 case 'store': case 'retrieve':
                     handleStorageAction(action as StorageAction, materialId as string);
                     break;
-                case 'worker':
+                case 'worker': case 'assembly':
                     handleHumanAction(action as HumanAction, materialId as string);
                     break;
                 default: