Legostaev_Gleb_Sergeevich_task_1

src/main/java/hse/java/practice/task1/RubiksCube.java

@@ -25,11 +25,149 @@ public RubiksCube() {
             edges[i] = new Edge(colors[i]);
         }
     }
+
+    public Edge[] deepCloneEdges() {
+        Edge[] edgesClone = new Edge[EDGES_COUNT];
+        for (int i = 0; i < EDGES_COUNT; i++) {
+            edgesClone[i] = new Edge(CubeColor.BLUE);
+        }
+        for (int i = 0; i < 6; i++) {
+            CubeColor[][] orig = edges[i].getParts();
+            CubeColor[][] edge = new CubeColor[3][3];
+            for (int j = 0; j < 3; j++) {
+                for (int k = 0; k < 3; k++) {
+                    edge[j][k] = orig[j][k];
+                }
+            }
+            edgesClone[i].setParts(edge);
+        }
+        return edgesClone;
+    }
+    // Представим грань curr перед собой. Тогда up/right/down/left это номера граней,
+    // находящихся в соответствующей стороне от curr
+    public void rotateClockwise(int curr, int up, int right, int down, int left) {
+        Edge[] edgesCopy = deepCloneEdges(); // Пусть копия будет хранить копию оригинала, а обновлять будем
+                                             // сразу оригинал, беря значения из копии
+
+        CubeColor[][] edgeFrontOriginal = edges[curr].getParts(); // Front, потому что мы curr представляем перед нами
+        CubeColor[][] edgeFrontCopy = edgesCopy[curr].getParts();
+
+        CubeColor[][] edgeUpOriginal = edges[up].getParts();
+        CubeColor[][] edgeUpCopy = edgesCopy[up].getParts();
+        CubeColor[][] edgeRightOriginal = edges[right].getParts();
+        CubeColor[][] edgeRightCopy = edgesCopy[right].getParts();
+        CubeColor[][] edgeDownOriginal = edges[down].getParts();
+        CubeColor[][] edgeDownCopy = edgesCopy[down].getParts();
+        CubeColor[][] edgeLeftOriginal = edges[left].getParts();
+        CubeColor[][] edgeLeftCopy = edgesCopy[left].getParts();
+
+        for (int i = 0; i < 3; i++) {
+            // Меняем переднюю грань
+            edgeFrontOriginal[0][i] = edgeFrontCopy[2-i][0];
+            edgeFrontOriginal[i][2] = edgeFrontCopy[0][i];
+            edgeFrontOriginal[2][i] = edgeFrontCopy[2-i][2];
+            edgeFrontOriginal[i][0] = edgeFrontCopy[2][i];
+            // Меняем смежные грани
+            if (curr == 0) {
+                edgeUpOriginal[0][i] = edgeLeftCopy[0][i];
+                edgeRightOriginal[0][i] = edgeUpCopy[0][i];
+                edgeDownOriginal[0][i] = edgeRightCopy[0][i];
+                edgeLeftOriginal[0][i] = edgeDownCopy[0][i];
+            }
+            else if (curr == 1){
+                edgeUpOriginal[2][i] = edgeLeftCopy[2][i];
+                edgeRightOriginal[2][i] = edgeUpCopy[2][i];
+                edgeDownOriginal[2][i] = edgeRightCopy[2][i];
+                edgeLeftOriginal[2][i] = edgeDownCopy[2][i];
+            }
+            else if (curr == 2) {
+                edgeUpOriginal[i][0] = edgeLeftCopy[2 - i][2];
+                edgeRightOriginal[i][0] = edgeUpCopy[i][0];
+                edgeDownOriginal[i][0] = edgeRightCopy[i][0];
+                edgeLeftOriginal[i][2] = edgeDownCopy[2-i][0];
+            }
+            else if (curr == 3) {
+                edgeUpOriginal[i][2] = edgeLeftCopy[i][2];
+                edgeRightOriginal[i][0] = edgeUpCopy[2 - i][2];
+                edgeDownOriginal[i][2] = edgeRightCopy[2 - i][0];
+                edgeLeftOriginal[i][2] = edgeDownCopy[i][2];
+            }
+            else if (curr == 4) {
+                edgeUpOriginal[2][i] = edgeLeftCopy[2 - i][2];
+                edgeRightOriginal[i][0] = edgeUpCopy[2][i];
+                edgeDownOriginal[0][i] = edgeRightCopy[2 - i][0];
+                edgeLeftOriginal[i][2] = edgeDownCopy[0][i];
+            }
+            else if (curr == 5) {
+                edgeUpOriginal[0][i] = edgeLeftCopy[i][2];
+                edgeRightOriginal[i][0] = edgeUpCopy[0][2 - i];
+                edgeDownOriginal[2][i] = edgeRightCopy[i][0];
+                edgeLeftOriginal[i][2] = edgeDownCopy[2][2 - i];
+            }
+        }
+
+    }
 
     public void front(RotateDirection direction) {
+        if (direction == RotateDirection.CLOCKWISE) {
+            rotateClockwise(4, 0, 3, 1, 2); // заполняем относительно того, какие грани по бокам
+        } else {
+            for (int i = 0; i < 3; i++) {
+                rotateClockwise(4, 0, 3, 1, 2);
+            }
+        }
+    }
+
+    public void back(RotateDirection direction) {
+        if (direction == RotateDirection.CLOCKWISE) {
+            rotateClockwise(5, 0, 2, 1, 3);
+        } else {
+            for (int i = 0; i < 3; i++) {
+                rotateClockwise(5, 0, 2, 1, 3);
+            }
+        }
+    }
 
+    public void up(RotateDirection direction) {
+        if (direction == RotateDirection.CLOCKWISE) {
+            rotateClockwise(0, 5, 3, 4, 2);
+        } else {
+            for (int i = 0; i < 3; i++) {
+                rotateClockwise(0, 5, 3, 4, 2);
+            }
+        }
     }
-
+
+    public void down(RotateDirection direction) {
+        if (direction == RotateDirection.CLOCKWISE) {
+            rotateClockwise(1, 4, 3, 5, 2);
+        } else {
+            for (int i = 0; i < 3; i++) {
+                rotateClockwise(1, 4, 3, 5, 2);
+            }
+        }
+    }
+
+    public void right(RotateDirection direction) {
+        if (direction == RotateDirection.CLOCKWISE) {
+            rotateClockwise(3, 0, 5, 1, 4);
+        } else {
+            for (int i = 0; i < 3; i++) {
+                rotateClockwise(3, 0, 5, 1, 4);
+            }
+        }
+    }
+
+    public void left(RotateDirection direction) {
+        if (direction == RotateDirection.CLOCKWISE) {
+            rotateClockwise(2, 0, 4, 1, 5);
+        } else {
+            for (int i = 0; i < 3; i++) {
+                rotateClockwise(2, 0, 4, 1, 5);
+            }
+        }
+    }
+
     public Edge[] getEdges() {
         return edges;
     }