refactoring

src/components/InteractiveObjects/MazeQuizGame/MazeObject.js

@@ -2,31 +2,21 @@ import { Group, Vector3, Matrix4, Mesh, Quaternion, PlaneGeometry, MeshStandardM
 import { InteractiveObject } from '../InteractiveObject';
 
 class MazeObject {
-    constructor(engine, def, params = {}){
+    constructor(engine, def, params){
         let room = new Group();
         let root = room;
         this.object = room;
-        let context = {};
-
         const bbox = {l:0, r:0, f:0}
+        const { wallSize, tubeSize, scale } = params
 
-        const scale = 5;
-
-        context.wallSize = params.wallSize || 1.2*scale; //half
-        context.tubeSize = params.tubeSize || 1.2*scale;
-        context.wallDepth = params.wallDepth || 0*scale;
-        context.fontPath = params.fontPath || '/static/fonts/Montserrat-Regular.ttf';
-        context.scale = scale;
-
-        this.context = context;
         let _tf = {
             rotation: {
                 r: 3 * Math.PI / 2, f: 0, l: Math.PI / 2, b: 0
             },
             pNext: {
-                r: [-context.wallSize/2, context.wallSize/2],
-                f: [0, context.wallSize],
-                l: [context.wallSize/2, context.wallSize/2]
+                r: [-wallSize/2, wallSize/2],
+                f: [0, wallSize],
+                l: [wallSize/2, wallSize/2]
             }
         };
 
@@ -53,7 +43,7 @@ class MazeObject {
 
             let e = elements.map(e=>o[e].clone())
 
-            e[0].position.set(0, 0, offsetZ + context.wallSize/2);
+            e[0].position.set(0, 0, offsetZ + wallSize/2);
 
             e[1].rotateY(_tf.rotation.b);
 
@@ -62,24 +52,24 @@ class MazeObject {
             e[4].rotateY(_tf.rotation.l);
 
             e[1].position.set(0, 0, offsetZ + 0);
-            e[2].position.set(-context.wallSize/2, 0, offsetZ + context.wallSize/2);
-            e[3].position.set(0, 0, offsetZ + context.wallSize);
-            e[4].position.set(context.wallSize/2, 0, offsetZ + context.wallSize/2);
+            e[2].position.set(-wallSize/2, 0, offsetZ + wallSize/2);
+            e[3].position.set(0, 0, offsetZ + wallSize);
+            e[4].position.set(wallSize/2, 0, offsetZ + wallSize/2);
 
             if (elements[1] == 'wall'){
-                addPhysics(def.matrix, [0, 0, offsetZ], context.wallSize, 'front')
+                addPhysics(def.matrix, [0, 0, offsetZ], wallSize, 'front')
             }
 
             if (elements[2] == 'wall'){
-                addPhysics(def.matrix, [-context.wallSize/2, 0, offsetZ + context.wallSize/2], context.wallSize)
+                addPhysics(def.matrix, [-wallSize/2, 0, offsetZ + wallSize/2], wallSize)
             }
 
             if (elements[3] == 'wall'){
-                addPhysics(def.matrix, [0, 0, offsetZ + context.wallSize], context.wallSize, 'front')
+                addPhysics(def.matrix, [0, 0, offsetZ + wallSize], wallSize, 'front')
             }
 
             if (elements[4] == 'wall'){
-                addPhysics(def.matrix, [context.wallSize/2, 0, offsetZ + context.wallSize/2], context.wallSize)
+                addPhysics(def.matrix, [wallSize/2, 0, offsetZ + wallSize/2], wallSize)
             }
 
             e.forEach(g => {
@@ -98,32 +88,32 @@ class MazeObject {
             let offsetZ = 0, e;
             def.len = def.len || 0;
             if (step == 0) {
-                addRoom(['floor', 'wall', 'wall', 'door', 'wall'], def, -context.wallSize)
+                addRoom(['floor', 'wall', 'wall', 'door', 'wall'], def, -wallSize)
             }
             if (def.userData?.answer !== undefined){
-                addPhysics(def.matrix, [0,0,0], context.wallSize, 'front', true, def.userData)
+                addPhysics(def.matrix, [0,0,0], wallSize, 'front', true, def.userData)
             }
             for (let i = 0; i < def.len; i++) {
                 let t = o.tunnel.clone();
-                t.position.set(0, 0, i * context.tubeSize);
+                t.position.set(0, 0, i * tubeSize);
                 def.matrix && t.applyMatrix4(def.matrix);
                 root.add(t);
             }
-            offsetZ = def.len * context.tubeSize;
-            addPhysics(def.matrix, [context.tubeSize / 2, 0.6, offsetZ/2], offsetZ)
-            addPhysics(def.matrix, [-context.tubeSize / 2, 0.6, offsetZ/2], offsetZ)
+            offsetZ = def.len * tubeSize;
+            addPhysics(def.matrix, [tubeSize / 2, 0.6, offsetZ/2], offsetZ)
+            addPhysics(def.matrix, [-tubeSize / 2, 0.6, offsetZ/2], offsetZ)
 
             addRoom(['floor', 'door', def.r ? 'door' : 'wall', def.f ? 'door' : 'wall', def.l ? 'door' : 'wall'], def, offsetZ)
             if (def.userData?.qid !== undefined || def.userData?.finish){
-                addPhysics(def.matrix, [0,0,offsetZ + context.wallSize/2], { width: context.wallSize/2, height: context.wallSize/2, depth: context.wallSize/2}, 'side', true, def.userData)
+                addPhysics(def.matrix, [0,0,offsetZ + wallSize/2], { width: wallSize/2, height: wallSize/2, depth: wallSize/2}, 'side', true, def.userData)
             }
             //console.log('loadingggg', def.objects)
             def.objects?.forEach(async obj => {
                 obj.room = room;
-                let go = new InteractiveObject(obj, engine, context)
+                let go = new InteractiveObject(engine, obj)
                 await go.ready;
-                go.object.scale.multiplyScalar(context.wallSize)
-                go.object.position.multiplyScalar(context.wallSize)
+                go.object.scale.multiplyScalar(wallSize)
+                go.object.position.multiplyScalar(wallSize)
                 go.object.applyMatrix4(def.matrix);
                 root.add(go.object);
             });