instead of standplane make four edges on each side top bottom left and right : shoot(event) {
        this.mouse.x = (event.clientX / window.innerWidth) * 2 - 1;
        this.mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
    
        this.raycaster.setFromCamera({ x: 0, y: 0 }, this.game.camera.instance);
    
        const intersects = this.raycaster.intersectObjects([
            this.plane, this.roof, this.scene.getObjectByName('backWall'),
            this.scene.getObjectByName('frontWall'), this.scene.getObjectByName('leftWall'),
            this.scene.getObjectByName('rightWall')
        ]);
    
        if (intersects.length > 0) {
            const intersection = intersects[0];
            const object = intersection.object;
    
            const geometry = new THREE.CircleGeometry(5, 32);
            const material = new THREE.MeshBasicMaterial({ color: 0x000000 });
            const circle = new THREE.Mesh(geometry, material);
    
            const portalSize = new THREE.Vector2(10, 15);
            const halfPortalSize = portalSize.clone().multiplyScalar(0.5);
            const wallSize = new THREE.Vector2(object.geometry.parameters.width, object.geometry.parameters.height);
            const halfWallSize = wallSize.clone().multiplyScalar(0.5);
    
            let localPosition = this.worldToLocal(object, intersection.point);
    
            localPosition.x = THREE.MathUtils.clamp(localPosition.x, -halfWallSize.x + halfPortalSize.x, halfWallSize.x - halfPortalSize.x);
            localPosition.y = THREE.MathUtils.clamp(localPosition.y, -halfWallSize.y + halfPortalSize.y, halfWallSize.y - halfPortalSize.y);
    
            const validPoint = this.localToWorld(object, localPosition);
    
            circle.position.copy(validPoint);
            circle.rotation.copy(object.rotation);
            circle.scale.y = 1.5;
    
            circle.position.addScaledVector(circle.getWorldDirection(new THREE.Vector3()), 0.01);
            
            // Create the physics body for the portal
            this.boxBody = new CANNON.Body({
                collisionFilterGroup: GROUP_PORTAL,
                collisionFilterMask: GROUP_WALL | GROUP_DEFAULT | GROUP_CUBE | GROUP_PLAYER,
            });
            this.boxBody.mass = 0;
            this.boxBody.material = this.defaultMaterial;
            this.boxBody.collisionResponse = false;
            this.boxBody.addShape(new CANNON.Box(new CANNON.Vec3(3.34, 5, 1.5)));
            this.boxBody.quaternion.copy(circle.quaternion);
            this.boxBody.position.copy(circle.position);
            this.boxBody.class = 'portal';
            this.boxBody.object = intersects[0].object;
    
            // Handle the intersection detection with the portal
            let intersectionDetected = false;
            if (event.button === 0) {
                this.rightPortal.forEach((rightPortal) => {
                    if (this.boxBody.object === rightPortal.physicObject.object && this.detectIntersection(this.boxBody, rightPortal.physicObject)) {
                        intersectionDetected = true;
                    }
                });
            } else if (event.button === 2) {
                this.leftPortal.forEach((leftPortal) => {
                    if (this.boxBody.object === leftPortal.physicObject.object && this.detectIntersection(this.boxBody, leftPortal.physicObject)) {
                        intersectionDetected = true;
                    }
                });
            }
    
            if (intersectionDetected) {
                return;
            }
    
            this.physics.addBody(this.boxBody);
            circle.physicObject = this.boxBody;
    
            const geometry1 = new THREE.PlaneGeometry(19, 19);
            let materialPortal;
    
            if (event.button === 0) {
                this.materialBlue = new THREE.ShaderMaterial({
                    uniforms: {
                        iResolution: { value: new THREE.Vector2(window.innerWidth, window.innerHeight) },
                        iTime: { value: 0 }
                    },
                    vertexShader: document.getElementById('vertexShader').textContent,
                    fragmentShader: document.getElementById('fragmentShaderOrange').textContent
                });
                materialPortal = this.materialBlue;
                this.boxBody.ref = 'left';
                this.leftPortal.push(circle);
            } else if (event.button === 2) {
                this.materialOrange = new THREE.ShaderMaterial({
                    uniforms: {
                        iResolution: { value: new THREE.Vector2(window.innerWidth, window.innerHeight) },
                        iTime: { value: 0 }
                    },
                    vertexShader: document.getElementById('vertexShader').textContent,
                    fragmentShader: document.getElementById('fragmentShaderBlue').textContent
                });
                materialPortal = this.materialOrange;
                this.boxBody.ref = 'right';
                this.rightPortal.push(circle);
            }
    
            const planePortal = new THREE.Mesh(geometry1, materialPortal);
            planePortal.position.copy(circle.position);
            planePortal.rotation.copy(circle.rotation);
            planePortal.position.addScaledVector(circle.getWorldDirection(new THREE.Vector3()), 0.01);
    
            this.scene.add(planePortal);
            circle.torus = planePortal;
    
            // Add a new plane for the player to stand on below the portal
            const standPlaneGeometry = new THREE.BoxGeometry(10, 0.1,0.1); // Adjust size as needed
            const standPlaneMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00, side: THREE.DoubleSide });
            const standPlane = new THREE.Mesh(standPlaneGeometry, standPlaneMaterial);
    
            // Position the stand plane below the portal
            standPlane.position.copy(circle.position);
            standPlane.position.y -= 5 * 1.5; // Adjust this value to control the height difference
            standPlane.quaternion.copy(circle.quaternion)
    
            this.scene.add(standPlane);
    
            // Create the physics body for the stand plane
            const standPlaneBody = new CANNON.Body({
                mass: 0,
                position: new CANNON.Vec3(standPlane.position.x, standPlane.position.y, standPlane.position.z),
                shape: new CANNON.Box(new CANNON.Vec3(10 / 2, 0.1 / 2, 4 / 2)),
                collisionFilterGroup: GROUP_DEFAULT,
                collisionFilterMask: GROUP_PLAYER
            });

            standPlaneBody.quaternion.copy(standPlane.quaternion)
    
            this.physics.addBody(standPlaneBody);
        }
    }