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,93 @@
+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()),
+ }),
+ } 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();
+
+ const chassisEntity = mockChassisWrapper.getEntity();
+ expect(chassisEntity.getTranslation).toHaveBeenCalled();
+ expect(chassisEntity.getRotation).toHaveBeenCalled();
+ 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();
+ });
+});