Part 2 robot simulator

src/__mocks__/emptyModule.js

@@ -0,0 +1 @@
+module.exports = {};

src/bundles/robot_simulation/controllers/__tests__/ev3/components/Chassis.ts

@@ -0,0 +1,88 @@
+import * as THREE from 'three';
+import { Physics, Renderer, EntityFactory , MeshFactory } from '../../../../engine';
+
+import { ChassisWrapper } from '../../../ev3/components/Chassis';
+
+jest.mock('../../../../engine', () => ({
+  Physics: jest.fn(),
+  Renderer: jest.fn(),
+  EntityFactory: { addCuboid: jest.fn() },
+  MeshFactory: { addCuboid: jest.fn() }
+}));
+jest.mock('../../../../engine/Entity/EntityFactory');
+
+jest.mock('three', () => {
+  const three = jest.requireActual('three');
+  return {
+    ...three,
+    Mesh: jest.fn().mockImplementation(() => ({
+      position: { copy: jest.fn() },
+      quaternion: { copy: jest.fn() },
+      visible: false,
+    })),
+    Color: jest.fn()
+  };
+});
+
+const mockedMeshFactory = MeshFactory as jest.Mocked<typeof MeshFactory>;
+const mockedEntityFactory = EntityFactory as jest.Mocked<typeof EntityFactory>;
+
+describe('ChassisWrapper', () => {
+  let physicsMock;
+  let rendererMock;
+  let chassisWrapper;
+  let config;
+
+  beforeEach(() => {
+    physicsMock = jest.fn() as unknown as Physics;
+    rendererMock = {add:jest.fn()} as unknown as Renderer;
+    config = {
+      dimension: { width: 1, height: 1, depth: 1 },
+      orientation: { x: 0, y: 0, z: 0, w: 1 },
+      debug: true
+    };
+
+    mockedMeshFactory.addCuboid.mockReturnValue(new THREE.Mesh());
+    chassisWrapper = new ChassisWrapper(physicsMock, rendererMock, config);
+
+  });
+
+  it('should initialize with a debug mesh if debug is true', () => {
+    expect(MeshFactory.addCuboid).toHaveBeenCalledWith({
+      orientation: config.orientation,
+      dimension: config.dimension,
+      color: expect.any(THREE.Color),
+      debug: true
+    });
+    expect(rendererMock.add).toBeCalled();
+    expect(chassisWrapper.debugMesh.visible).toBe(true);
+  });
+
+  it('should throw if getEntity is called before chassis is initialized', () => {
+    expect(chassisWrapper.chassis).toBe(null);
+    expect(() => chassisWrapper.getEntity()).toThrow('Chassis not initialized');
+  });
+
+  it('should correctly initialize the chassis entity on start', async () => {
+    const mockEntity = { getTranslation: jest.fn(), getRotation: jest.fn() };
+    mockedEntityFactory.addCuboid.mockReturnValue(mockEntity as any);
+    await chassisWrapper.start();
+
+    expect(chassisWrapper.chassis).toBe(mockEntity);
+    expect(EntityFactory.addCuboid).toHaveBeenCalledWith(physicsMock, config);
+  });
+
+  it('should update the position and orientation of the debug mesh to match the chassis entity', () => {
+    const mockEntity = {
+      getTranslation: jest.fn().mockReturnValue(new THREE.Vector3()),
+      getRotation: jest.fn().mockReturnValue(new THREE.Quaternion())
+    };
+    mockedEntityFactory.addCuboid.mockReturnValue(mockEntity as any);
+    chassisWrapper.chassis = mockEntity;
+
+    chassisWrapper.update();
+
+    expect(chassisWrapper.debugMesh.position.copy).toHaveBeenCalledWith(mockEntity.getTranslation());
+    expect(chassisWrapper.debugMesh.quaternion.copy).toHaveBeenCalledWith(mockEntity.getRotation());
+  });
+});

src/bundles/robot_simulation/controllers/__tests__/ev3/components/Mesh.ts

@@ -0,0 +1,105 @@
+import * as THREE from 'three';
+import { Renderer } from '../../../../engine';
+import { loadGLTF } from '../../../../engine/Render/helpers/GLTF';
+import { ChassisWrapper } from '../../../ev3/components/Chassis';
+import { Mesh } from '../../../ev3/components/Mesh';
+
+jest.mock('three', () => {
+  const three = jest.requireActual('three');
+  return {
+    ...three,
+    GLTF: jest.fn().mockImplementation(() => ({
+      scene: {},
+    })),
+  };
+});
+
+jest.mock('../../../../engine/Render/helpers/GLTF', () => ({
+  loadGLTF: jest.fn().mockResolvedValue({
+    scene: {
+      position: {
+        copy: jest.fn(),
+      },
+      quaternion: {
+        copy: jest.fn(),
+      },
+    },
+  }),
+}));
+
+jest.mock('../../../ev3/components/Chassis', () => ({
+  ChassisWrapper: jest.fn().mockImplementation(() => ({
+    getEntity: jest.fn().mockReturnValue({
+      getTranslation: jest.fn().mockReturnValue(new THREE.Vector3()),
+      getRotation: jest.fn().mockReturnValue(new THREE.Quaternion()),
+    }),
+  })),
+}));
+
+jest.mock('../../../../engine', () => ({
+  Renderer: jest.fn().mockImplementation(() => ({
+    add: jest.fn(),
+  })),
+}));
+
+describe('Mesh', () => {
+  let mesh;
+  let mockChassisWrapper;
+  let mockRenderer;
+  let mockConfig;
+
+  beforeEach(() => {
+    mockRenderer = { add: jest.fn() } as unknown as Renderer;
+    mockChassisWrapper = {
+      getEntity: jest.fn().mockReturnValue({
+        getTranslation: jest.fn().mockReturnValue(new THREE.Vector3()),
+        getRotation: jest.fn().mockReturnValue(new THREE.Quaternion()),
+      }),
+      config: {
+        orientation: {
+          position: {
+            x: 0,
+            y: 0.0775,
+            z: 0,
+          },
+          rotation: {
+            x: 0,
+            y: 0,
+            z: 0,
+            w: 1,
+          },
+        },
+      }
+    } as unknown as ChassisWrapper;
+    mockConfig = {
+      url: 'path/to/mesh',
+      dimension: { width: 1, height: 2, depth: 3 },
+      offset: { x: 0.5, y: 0.5, z: 0.5 },
+    };
+
+    // mockLoadGLTF.mockResolvedValue({
+    //   scene: new THREE.GLTF().scene
+    // } as any);
+
+    mesh = new Mesh(mockChassisWrapper, mockRenderer, mockConfig);
+  });
+
+  it('should initialize correctly with given configurations', () => {
+    expect(mesh.config.url).toBe(mockConfig.url);
+    expect(mesh.offset.x).toBe(0.5);
+  });
+
+  it('should load the mesh and add it to the renderer on start', async () => {
+    await mesh.start();
+    expect(loadGLTF).toHaveBeenCalledWith(mockConfig.url, mockConfig.dimension);
+    expect(mockRenderer.add).toHaveBeenCalledWith(expect.any(Object)); // Checks if mesh scene is added to renderer
+  });
+
+  it('should update mesh position and orientation according to chassis', async () => {
+    await mesh.start();
+    mesh.update({residualFactor: 0.5});
+
+    expect(mesh.mesh.scene.position.copy).toHaveBeenCalled();
+    expect(mesh.mesh.scene.quaternion.copy).toHaveBeenCalled();
+  });
+});

src/bundles/robot_simulation/controllers/__tests__/ev3/components/Motor.ts

@@ -0,0 +1,118 @@
+import * as THREE from 'three';
+import { Renderer, Physics } from '../../../../engine';
+import { loadGLTF } from '../../../../engine/Render/helpers/GLTF';
+import { ChassisWrapper } from '../../../ev3/components/Chassis';
+import { Motor } from '../../../ev3/components/Motor';
+import { ev3Config } from '../../../ev3/ev3/default/config';
+
+jest.mock('three', () => {
+  const originalModule = jest.requireActual('three');
+  return {
+    ...originalModule,
+  };
+});
+
+jest.mock('../../../../engine/Render/helpers/GLTF', () => ({
+  loadGLTF: jest.fn().mockResolvedValue({
+    scene: {
+      position: {
+        copy: jest.fn(),
+      },
+      quaternion: {
+        copy: jest.fn(),
+      },
+      rotateX: jest.fn(),
+      rotateZ: jest.fn()
+    }
+  }),
+}));
+
+jest.mock('../../../../engine', () => ({
+  Physics: jest.fn(),
+  Renderer: jest.fn().mockImplementation(() => ({
+    add: jest.fn(),
+  })),
+}));
+
+jest.mock('../../../ev3/components/Chassis', () => ({
+  ChassisWrapper: jest.fn().mockImplementation(() => ({
+    getEntity: jest.fn().mockReturnValue({
+      transformDirection: jest.fn().mockImplementation((v) => v),
+      worldVelocity: jest.fn().mockReturnValue(new THREE.Vector3()),
+      worldTranslation: jest.fn().mockReturnValue(new THREE.Vector3()),
+      applyImpulse: jest.fn(),
+      getMass: jest.fn().mockReturnValue(1),
+      getRotation: jest.fn(),
+    }),
+  })),
+}));
+
+describe('Motor', () => {
+  let motor;
+  let mockChassisWrapper;
+  let mockPhysics;
+  let mockRenderer;
+  let mockConfig;
+
+  beforeEach(() => {
+    mockPhysics = {
+      applyImpulse: jest.fn(),
+    } as unknown as Physics;
+    mockRenderer = { add: jest.fn() } as unknown as Renderer;
+    mockConfig = {
+      displacement: { x: 1, y: 0, z: 0 },
+      pid: {
+        proportionalGain: 1,
+        integralGain: 0.1,
+        derivativeGain: 0.01,
+      },
+      mesh: {
+        url: 'path/to/mesh',
+        dimension: { height: 1, width: 1, depth: 1 },
+      },
+    };
+    const config = ev3Config.motors[0];
+    mockChassisWrapper = new ChassisWrapper(mockPhysics, mockRenderer, config);
+    motor = new Motor(
+      mockChassisWrapper,
+      mockPhysics,
+      mockRenderer,
+      mockConfig
+    );
+  });
+
+  it('should initialize correctly and load the mesh', async () => {
+    await motor.start();
+    expect(loadGLTF).toHaveBeenCalledWith(
+      mockConfig.mesh.url,
+      mockConfig.mesh.dimension
+    );
+    expect(mockRenderer.add).toHaveBeenCalled();
+  });
+
+  it('sets motor velocity and schedules stop with distance', () => {
+    motor.setSpeedDistance(10, 100);
+    expect(motor.motorVelocity).toBe(10);
+  });
+
+  it('updates the motor velocity and applies impulse', () => {
+    motor.fixedUpdate({ deltaTime: 1 });
+    expect(mockChassisWrapper.getEntity().applyImpulse).toHaveBeenCalled();
+  });
+
+  it('updates mesh', async () => {
+    await motor.start();
+    motor.update({frameDuration: 1});
+
+    expect(motor.mesh.scene.position.copy).toBeCalled();
+    expect(motor.mesh.scene.quaternion.copy).toBeCalled();
+  });
+
+  it('rotates the mesh if on the left side', async () => {
+    motor.wheelSide = 'left';
+    await motor.start();
+    motor.update({frameDuration: 1});
+
+    expect(motor.mesh.scene.rotateZ).toBeCalled();
+  });
+});