Rubik's Cube Solver mit 3D-Darstellung

  • C#

Es gibt 85 Antworten in diesem Thema. Der letzte Beitrag () ist von Switcherlapp97.

    @StarGate01
    Darum habe ich ja geschrieben "Möglichkeit" :P
    Aber es wäre schon extrem geil, wenn das mit der Webcam realisierbar wäre ;)
    RubiksCubeSolver


    Jetzt im Showroom

    Rubik's Cube Solver - Schritt 1: Erstes Kreuz

    Hallo,

    Wie ich bereits geschrieben habe, arbeite ich derzeit an einem Rubiks Cube Solver. Jetzt habe ich es geschafft, dass mein Programm schon das erste Kreuz auf der Bottom-Ebene lösen kann :thumbsup:
    Ich habe die Bottom-Ebene bewusst als die Ebene für das erste Kreuz gewählt, da später die erste Seite des Cubes immer unten gehalten wird und ich so eine Drehung des kompletten Würfels vermeide.

    Vorgehensweise

    Vorbereitungen
    - die Farbe der unteren Fläche ermitteln
    - einen neuen RubikManager erstellen, der gelöst ist und mit dem man die Zielpositionen der einzelnen Steine herausfinden kann
    - die Flächen des neu erstellten RubikManager so wie die Mittelsteine des Eingabecubes färben.
    - alle Kanten, die eine Fläche in der Farbe der Bottom Ebene gefärbt haben in eine Liste hinzufügen

    Lösen der Kanten (Schritte, die für alle Kanten abgearbeitet werden müssen)
    - Zielposition ermitteln
    - die Kante auf die Top-Ebene drehen
    - die Kante über die Zielposition auf der Top-Ebene rotieren
    - die Kante an die Zielposition drehen
    - falls die Kante verkehrt herum an der Zielposition liegt mit dem Algorithmus Fi D Ri Di flippen

    :!: Als Grundlage habe ich das Programm VirtualRubik von @StarGate01 verwendet. Falls ihr den Code selbst testen wollt, downloadet euch die Version 1.2 und setzt den Code dort ein.

    Code
    Cube3D.cs

    Die isEdge-Methode gibt zurück, ob ein Cube mit der eingegebenen Koordinaten eine Kante ist oder nicht:

    C#-Quellcode

    1. public static Boolean isEdge(RubikPosition Position)
    2. {
    3. return ((Position == (RubikPosition.TopLayer | RubikPosition.FrontSlice | RubikPosition.MiddleSlice_Sides))
    4. || (Position == (RubikPosition.TopLayer | RubikPosition.BackSlice | RubikPosition.MiddleSlice_Sides))
    5. || (Position == (RubikPosition.TopLayer | RubikPosition.RightSlice | RubikPosition.MiddleSlice))
    6. || (Position == (RubikPosition.TopLayer | RubikPosition.LeftSlice | RubikPosition.MiddleSlice))
    7. || (Position == (RubikPosition.MiddleLayer | RubikPosition.FrontSlice | RubikPosition.RightSlice))
    8. || (Position == (RubikPosition.MiddleLayer | RubikPosition.FrontSlice | RubikPosition.LeftSlice))
    9. || (Position == (RubikPosition.MiddleLayer | RubikPosition.BackSlice | RubikPosition.RightSlice))
    10. || (Position == (RubikPosition.MiddleLayer | RubikPosition.BackSlice | RubikPosition.LeftSlice))
    11. || (Position == (RubikPosition.BottomLayer | RubikPosition.FrontSlice | RubikPosition.MiddleSlice_Sides))
    12. || (Position == (RubikPosition.BottomLayer | RubikPosition.BackSlice | RubikPosition.MiddleSlice_Sides))
    13. || (Position == (RubikPosition.BottomLayer | RubikPosition.RightSlice | RubikPosition.MiddleSlice))
    14. || (Position == (RubikPosition.BottomLayer | RubikPosition.LeftSlice | RubikPosition.MiddleSlice)));
    15. }


    RubikManager.cs

    Ich habe die Rotate90-Methode ein bisschen angepasst, damit das mit den Drehrichtungen stimmt:

    C#-Quellcode

    1. public void Rotate90(Cube3D.RubikPosition layer, bool direction, int steps)
    2. {
    3. if (!Rotating)
    4. {
    5. Rotating = true;
    6. rotationLayer = layer;
    7. rotationStep = (double)90 / (double)steps;
    8. rotationTarget = 90;
    9. if (direction && (layer == Cube3D.RubikPosition.BottomLayer || layer == Cube3D.RubikPosition.BackSlice || layer == Cube3D.RubikPosition.RightSlice || layer == Cube3D.RubikPosition.MiddleSlice_Sides) ||
    10. !direction && (layer == Cube3D.RubikPosition.TopLayer || layer == Cube3D.RubikPosition.FrontSlice || layer == Cube3D.RubikPosition.LeftSlice ||
    11. layer == Cube3D.RubikPosition.MiddleLayer || layer == Cube3D.RubikPosition.MiddleSlice))
    12. {
    13. rotationStep *= (-1);
    14. rotationTarget = -90;
    15. }
    16. }
    17. }

    Ich habe in der RubikManager noch eine Methode komplett neu erstellt. Es ist die getFaceColor-Methode, die von einem Cube an einer bestimmten Position die Farbe einer bestimmten Fläche zurückgibt.

    C#-Quellcode

    1. public Color getFaceColor(Cube3D.RubikPosition position, Face3D.FacePosition face)
    2. {
    3. return RubikCube.cubes.First(c => c.Position.HasFlag(position)).Faces.First(f => f.Position == face).Color;
    4. }


    CubeSolver.cs

    Für das Lösen des Cubes habe ich eine neue Klasse erstellt (CubeSolver). Hier der bisherige Code der Klasse:

    C#-Quellcode

    1. class CubeSolver
    2. {
    3. RubikManager Manager;
    4. private RubikManager standardCube = new RubikManager();
    6. public CubeSolver(RubikManager rubik)
    7. {
    8. Manager = rubik;
    9. }
    11. public Stack<LayerMove> SolveFirstCross()
    12. {
    13. List<LayerMove> Moves = new List<LayerMove>();
    15. //Step 1: Get the color of the bottom layer to start with the first cross
    16. Color bottomColor = Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom);
    18. //Step 2: Change colors of the faces
    19. standardCube.setFaceColor(Cube3D.RubikPosition.TopLayer, Face3D.FacePosition.Top,
    20. Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top));
    22. standardCube.setFaceColor(Cube3D.RubikPosition.BottomLayer, Face3D.FacePosition.Bottom,
    23. Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom));
    25. standardCube.setFaceColor(Cube3D.RubikPosition.RightSlice, Face3D.FacePosition.Right,
    26. Manager.getFaceColor(Cube3D.RubikPosition.RightSlice | Cube3D.RubikPosition.MiddleSlice | Cube3D.RubikPosition.MiddleLayer, Face3D.FacePosition.Right));
    28. standardCube.setFaceColor(Cube3D.RubikPosition.LeftSlice, Face3D.FacePosition.Left,
    29. Manager.getFaceColor(Cube3D.RubikPosition.LeftSlice | Cube3D.RubikPosition.MiddleSlice | Cube3D.RubikPosition.MiddleLayer, Face3D.FacePosition.Left));
    31. standardCube.setFaceColor(Cube3D.RubikPosition.FrontSlice, Face3D.FacePosition.Front,
    32. Manager.getFaceColor(Cube3D.RubikPosition.MiddleLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.FrontSlice, Face3D.FacePosition.Front));
    34. standardCube.setFaceColor(Cube3D.RubikPosition.BackSlice, Face3D.FacePosition.Back,
    35. Manager.getFaceColor(Cube3D.RubikPosition.MiddleLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.BackSlice, Face3D.FacePosition.Back));
    37. //Step 3: Get edges with of the bottom face
    38. IEnumerable<Cube3D> whiteEdges = Manager.RubikCube.cubes.Where(c => Cube3D.isEdge(c.Position)).Where(c => c.Faces.Count(f => f.Color == bottomColor) == 1);
    40. //Step 4: Solve the first cross
    41. foreach (Cube3D c in whiteEdges)
    42. {
    43. //Step 4.1: Get the target position and the second color of the edge
    44. Cube3D.RubikPosition targetPosition = standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, c.Colors)).Position;
    45. Color secondColor = c.Colors.First(co => co != bottomColor && co != Color.Black);
    47. //Step 4.2: Rotate to target position
    48. if (c.Position != targetPosition)
    49. {
    50. //Rotate to top layer
    51. Cube3D.RubikPosition layer = FacePosToCubePos(c.Faces.First(f => (f.Color == bottomColor || f.Color == secondColor)
    52. && f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom).Position);
    54. if (c.Position.HasFlag(Cube3D.RubikPosition.MiddleLayer))
    55. {
    56. Manager.Rotate90Sync(layer, true);
    57. if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    58. {
    59. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    60. Manager.Rotate90Sync(layer, false);
    61. }
    62. else
    63. {
    64. for (int i = 0; i < 2; i++) Manager.Rotate90Sync(layer, false);
    65. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    66. Manager.Rotate90Sync(layer, true);
    67. }
    68. }
    69. if (c.Position.HasFlag(Cube3D.RubikPosition.BottomLayer)) for (int i = 0; i < 2; i++) Manager.Rotate90Sync(layer, true);
    71. //Rotate over target position
    72. Cube3D.RubikPosition targetLayer = FacePosToCubePos(standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, c.Colors))
    73. .Faces.First(f => f.Color == secondColor).Position);
    74. while (!RefreshCube(c).Position.HasFlag(targetLayer)) Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    76. //Rotate to target position
    77. for (int i = 0; i < 2; i++) Manager.Rotate90Sync(targetLayer, true);
    78. }
    80. //Step 4.3: Flip the incorrect orientated edges with the algorithm: Fi D Ri Di
    81. if (c.Faces.First(f => f.Position == Face3D.FacePosition.Bottom).Color != bottomColor)
    82. {
    83. Cube3D.RubikPosition frontLayer = FacePosToCubePos(c.Faces.First(f => f.Color == bottomColor).Position);
    84. Manager.Rotate90Sync(frontLayer, false);
    85. Manager.Rotate90Sync(Cube3D.RubikPosition.BottomLayer, true);
    87. Cube3D.RubikPosition rightSlice = FacePosToCubePos(RefreshCube(c).Faces.First(f => f.Color == secondColor).Position);
    89. Manager.Rotate90Sync(rightSlice, false);
    90. Manager.Rotate90Sync(Cube3D.RubikPosition.BottomLayer, false);
    91. }
    92. }
    93. Moves.Reverse();
    95. return new Stack<LayerMove>(Moves);
    96. }
    98. private Cube3D.RubikPosition FacePosToCubePos(Face3D.FacePosition position)
    99. {
    100. switch (position)
    101. {
    102. case Face3D.FacePosition.Top:
    103. return Cube3D.RubikPosition.TopLayer;
    104. case Face3D.FacePosition.Bottom:
    105. return Cube3D.RubikPosition.BottomLayer;
    106. case Face3D.FacePosition.Left:
    107. return Cube3D.RubikPosition.LeftSlice;
    108. case Face3D.FacePosition.Right:
    109. return Cube3D.RubikPosition.RightSlice;
    110. case Face3D.FacePosition.Back:
    111. return Cube3D.RubikPosition.BackSlice;
    112. case Face3D.FacePosition.Front:
    113. return Cube3D.RubikPosition.FrontSlice;
    114. default:
    115. return Cube3D.RubikPosition.None;
    116. }
    117. }
    119. private Cube3D RefreshCube(Cube3D cube)
    120. {
    121. return Manager.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, cube.Colors));
    122. }
    124. public static bool ScrambledEquals<T>(IEnumerable<T> list1, IEnumerable<T> list2)
    125. {
    126. var cnt = new Dictionary<T, int>();
    127. foreach (T s in list1)
    128. {
    129. if (cnt.ContainsKey(s))
    130. {
    131. cnt[s]++;
    132. }
    133. else
    134. {
    135. cnt.Add(s, 1);
    136. }
    137. }
    138. foreach (T s in list2)
    139. {
    140. if (cnt.ContainsKey(s))
    141. {
    142. cnt[s]--;
    143. }
    144. else
    145. {
    146. return false;
    147. }
    148. }
    149. return cnt.Values.All(c => c == 0);
    150. }
    151. }


    Form1.cs

    In der Form habe ich dann einen neuen Button erstellt (button7) und mit einem Klick auf diesen Button wird das erste Kreuz gelöst:

    C#-Quellcode

    1. private void button7_Click(object sender, EventArgs e)
    2. {
    3. CubeSolver cs = new CubeSolver(rubikManager);
    4. moveStack = cs.SolveFirstCross();
    5. }


    Ich verstehe allerdings nicht, wieso die 3D-Darstellung sich immer gleich mitdreht wenn ich die Rotate90Sync in der CubeSolver-Klasse aufrufe. Wie kann ich das noch verändern, dass der Cube in der Klasse unabhängig vom Cube in der 3D-Darstellung gedreht werden kann?

    Danke
    Switcherlapp97
    Dateien
    RubiksCubeSolver


    Jetzt im Showroom

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Switcherlapp97“ ()

    Nice! Ich sehs mir gerade durch.
    Aber ich hab einen Tipp schon mal so: nimm bitte die Version 1.3 von VirtualRubik als Basis.
    Das ist das vorerst letzte Update wo zentrale Funktionen geändert wurden. Die nächsten Updates werden nicht mehr so tief eingreifen.
    Außerdem sind in der 1.3 ein paar nervige Bugs gefixed, und die neue UI dürfte Dir auch hilfreich sein :)
    Wenn Du willst, nehme ich Dein Programm auch als "offiziellen" Fork in mein Topic auf.

    Zu Deiner Frage:
    Du müsstest wohl zwei Instanzen des Würfels erstellen, eine zum Rendern und eine zum rumdrehen.
    SᴛᴀʀGᴀᴛᴇ01

    Gut dann werde ich nun die Version 1.3 als Grundlage für mein Projekt verwenden ;)

    StarGate01 schrieb:

    Wenn Du willst, nehme ich Dein Programm auch als "offiziellen" Fork in mein Topic auf.

    Ich habe nichts dagegen :D

    Ich wäre allerdings froh, wenn du mir das mit den zwei Instanzen genauer erklären könntest :S
    RubiksCubeSolver


    Jetzt im Showroom

    Hallo,

    Nun löst mein Code schon die komplette untere Ebene. Den Code und weitere Informationen zum RubiksCubeSolver Projekt findet ihr auf GitHub :)

    Gruß
    Switcherlapp97
    RubiksCubeSolver


    Jetzt im Showroom

    Hallo,

    Ich habe es nun geschafft den Cube mit Hilfe von Code zu lösen. Für das Lösen verwende ich aktuell die Anfängermethode (Projekt-Download von GitHub). Nach dem Fertigstellen des Codes habe ich 1000x mit 50 Moves verdrehte Würfel von meinem Programm lösen lassen und die Anzahl der benötigten Moves sowie die benötigte Zeit in eine CSV-Datei geschrieben und dann in Excel ein paar Werte ausgerechnet. Hier das Ergebnis:

    Zeit
    Durchschnittlich benötigte Zeit: 475ms
    Kürzeste Zeit: 270ms
    Längste Zeit: 880ms

    Moves
    Durchschnittlich benötigte Moves: 290
    Geringste Anzahl an Moves: 190
    Größte Anzahl an Moves: 366

    Die Werte der benötigten Moves sind für mich noch nicht zufriedenstellend, wenn man bedenkt, dass jeder Rubiks Cube in maximal 20 Zügen gelöst werden kann. Diese Zahl werde ich sicher nicht erreichen, da bei 20 Zügen die absolut schnellste Lösung berechnet wird, die nicht wirklich auf einen Lösealgorithmus zurückgeht. Ich möchte die durchschnittliche Anzahl der Moves auf jeden Fall wenn möglich noch ordentlich reduzieren.

    CubeSolver.cs

    Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Drawing;
    7. namespace VirtualRubik
    8. {
    9. class CubeSolver
    10. {
    11. RubikManager Manager;
    12. private RubikManager standardCube = new RubikManager();
    14. public void Solve()
    15. {
    16. SolveFirstCross();
    17. CompleteFirstLayer();
    18. CompleteMiddleLayer();
    19. SolveCrossTopLayer();
    20. CompleteLastLayer();
    21. }
    23. public CubeSolver(RubikManager rubik)
    24. {
    25. Manager = rubik;
    27. //Change colors of the faces
    28. standardCube.setFaceColor(Cube3D.RubikPosition.TopLayer, Face3D.FacePosition.Top,
    29. Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top));
    31. standardCube.setFaceColor(Cube3D.RubikPosition.BottomLayer, Face3D.FacePosition.Bottom,
    32. Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom));
    34. standardCube.setFaceColor(Cube3D.RubikPosition.RightSlice, Face3D.FacePosition.Right,
    35. Manager.getFaceColor(Cube3D.RubikPosition.RightSlice | Cube3D.RubikPosition.MiddleSlice | Cube3D.RubikPosition.MiddleLayer, Face3D.FacePosition.Right));
    37. standardCube.setFaceColor(Cube3D.RubikPosition.LeftSlice, Face3D.FacePosition.Left,
    38. Manager.getFaceColor(Cube3D.RubikPosition.LeftSlice | Cube3D.RubikPosition.MiddleSlice | Cube3D.RubikPosition.MiddleLayer, Face3D.FacePosition.Left));
    40. standardCube.setFaceColor(Cube3D.RubikPosition.FrontSlice, Face3D.FacePosition.Front,
    41. Manager.getFaceColor(Cube3D.RubikPosition.MiddleLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.FrontSlice, Face3D.FacePosition.Front));
    43. standardCube.setFaceColor(Cube3D.RubikPosition.BackSlice, Face3D.FacePosition.Back,
    44. Manager.getFaceColor(Cube3D.RubikPosition.MiddleLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.BackSlice, Face3D.FacePosition.Back));
    45. }
    47. //Solve the first cross on the bottom layer
    48. private void SolveFirstCross()
    49. {
    50. int Moves = 0;
    51. //Step 1: Get the color of the bottom layer to start with the first cross
    52. Color bottomColor = Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom);
    54. //Step 3: Get edges with the color of the bottom face
    55. IEnumerable<Cube3D> bottomEdges = Manager.RubikCube.cubes.Where(c => Cube3D.isEdge(c.Position)).Where(c => c.Colors.Count(co => co == bottomColor) == 1);
    57. //Step 4: Solve the first cross
    58. foreach (Cube3D c in bottomEdges)
    59. {
    60. //Step 4.1: Get the target position and the second color of the edge
    61. Cube3D.RubikPosition targetPosition = standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, c.Colors)).Position;
    62. Color secondColor = c.Colors.First(co => co != bottomColor && co != Color.Black);
    64. //Step 4.2: Rotate to target position
    65. if (c.Position != targetPosition)
    66. {
    67. //Rotate to top layer
    68. Cube3D.RubikPosition layer = FacePosToCubePos(c.Faces.First(f => (f.Color == bottomColor || f.Color == secondColor)
    69. && f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom).Position);
    71. if (c.Position.HasFlag(Cube3D.RubikPosition.MiddleLayer))
    72. {
    73. Moves++;
    74. Manager.Rotate90Sync(layer, true);
    75. if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    76. {
    77. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    78. Manager.Rotate90Sync(layer, false);
    79. }
    80. else
    81. {
    82. for (int i = 0; i < 2; i++) Manager.Rotate90Sync(layer, true);
    83. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    84. Manager.Rotate90Sync(layer, true);
    85. }
    86. }
    87. if (c.Position.HasFlag(Cube3D.RubikPosition.BottomLayer)) for (int i = 0; i < 2; i++) Manager.Rotate90Sync(layer, true);
    89. //Rotate over target position
    90. Cube3D.RubikPosition targetLayer = FacePosToCubePos(standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, c.Colors))
    91. .Faces.First(f => f.Color == secondColor).Position);
    92. while (!RefreshCube(c).Position.HasFlag(targetLayer)) Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    94. //Rotate to target position
    95. for (int i = 0; i < 2; i++) Manager.Rotate90Sync(targetLayer, true);
    96. }
    98. //Step 4.3: Flip the incorrect orientated edges with the algorithm: Fi D Ri Di
    99. if (c.Faces.First(f => f.Position == Face3D.FacePosition.Bottom).Color != bottomColor)
    100. {
    101. Cube3D.RubikPosition frontLayer = FacePosToCubePos(RefreshCube(c).Faces.First(f => f.Color == bottomColor).Position);
    102. Manager.Rotate90Sync(frontLayer, false);
    103. Manager.Rotate90Sync(Cube3D.RubikPosition.BottomLayer, true);
    105. Cube3D.RubikPosition rightSlice = FacePosToCubePos(RefreshCube(c).Faces.First(f => f.Color == secondColor).Position);
    107. Manager.Rotate90Sync(rightSlice, false);
    108. Manager.Rotate90Sync(Cube3D.RubikPosition.BottomLayer, false);
    109. }
    110. }
    111. }
    113. private void CompleteFirstLayer()
    114. {
    115. //Step 1: Get the color of the bottom layer
    116. Color bottomColor = Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom);
    118. //Step 2: Get corners with the color of the bottom face
    119. IEnumerable<Cube3D> bottomCorners = Manager.RubikCube.cubes.Where(c => Cube3D.isCorner(c.Position)).Where(c => c.Colors.Count(co => co == bottomColor) == 1);
    121. //Step 3: Complete the first layer
    122. foreach (Cube3D c in bottomCorners)
    123. {
    124. //3.1 Get the target position
    125. Cube3D.RubikPosition targetPosition = standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, c.Colors)).Position;
    127. //3.2 Rotate to target position
    128. if (c.Position != targetPosition)
    129. {
    130. //Rotate to top layer
    131. if (c.Position.HasFlag(Cube3D.RubikPosition.BottomLayer))
    132. {
    133. Face3D leftFace = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Bottom && f.Color != Color.Black);
    134. Cube3D.RubikPosition leftSlice = FacePosToCubePos(leftFace.Position);
    135. Manager.Rotate90Sync(leftSlice, false);
    136. if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.BottomLayer))
    137. {
    138. Manager.Rotate90Sync(leftSlice, true);
    139. leftFace = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Bottom && f.Color != leftFace.Color && f.Color != Color.Black);
    140. leftSlice = FacePosToCubePos(leftFace.Position);
    141. Manager.Rotate90Sync(leftSlice, false);
    142. }
    143. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    144. Manager.Rotate90Sync(leftSlice, true);
    145. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    146. }
    148. //Rotate over target position
    149. Cube3D.RubikPosition targetPos = Cube3D.RubikPosition.None;
    150. foreach (Cube3D.RubikPosition p in GetFlags(targetPosition))
    151. {
    152. if (p != Cube3D.RubikPosition.BottomLayer)
    153. targetPos |= p;
    154. }
    156. while (!RefreshCube(c).Position.HasFlag(targetPos)) Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    157. }
    159. //Rotate to target position with the algorithm: Li Ui L U
    160. Face3D leftFac = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom && f.Color != Color.Black);
    161. Cube3D.RubikPosition leftSlic = FacePosToCubePos(leftFac.Position);
    162. Manager.Rotate90Sync(leftSlic, false);
    163. if (!RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    164. {
    165. Manager.Rotate90Sync(leftSlic, true);
    166. leftFac = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom && f.Color != leftFac.Color && f.Color != Color.Black);
    167. leftSlic = FacePosToCubePos(leftFac.Position);
    168. }
    169. else Manager.Rotate90Sync(leftSlic, true);
    171. while (RefreshCube(c).Faces.First(f => f.Color == bottomColor).Position != Face3D.FacePosition.Bottom)
    172. {
    173. Manager.Rotate90Sync(leftSlic, false);
    174. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    175. Manager.Rotate90Sync(leftSlic, true);
    176. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    177. }
    178. }
    179. }
    181. private void CompleteMiddleLayer()
    182. {
    183. //Step 1: Get the color of the bottom and top layer
    184. Color bottomColor = Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom);
    185. Color topColor = Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top);
    187. //Step 2: Get the egdes of the middle layer
    188. IEnumerable<Cube3D> middleEdges = Manager.RubikCube.cubes.Where(c => Cube3D.isEdge(c.Position)).Where(c => c.Colors.Count(co => co == bottomColor || co == topColor) == 0);
    190. //Step 3: Complete the middle layer
    191. foreach (Cube3D c in middleEdges)
    192. {
    193. //3.1 Get the target position
    194. Cube3D.RubikPosition targetPosition = standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, c.Colors)).Position;
    196. //BUG:
    197. //Wenn ein Stein bereits richtig positioniert und ausgerichtet ist, aber falsch orientiert, passiert aktuell noch nichts
    199. //Check correct orientation
    200. List<Face3D> coloredFaces = new List<Face3D>();
    201. Manager.RubikCube.cubes.Where(cu => Cube3D.isCenter(cu.Position)).ToList().ForEach(cu => coloredFaces.Add(cu.Faces.First(f => f.Color != Color.Black)));
    202. bool correctOrientation = c.Faces.Count(f => coloredFaces.Count(cf => cf.Color == f.Color && cf.Position == f.Position) == 1) == 2;
    204. //3.2 Rotate to target position
    205. if (c.Position != targetPosition || (c.Position == targetPosition && !correctOrientation))
    206. {
    207. //Rotate to top layer
    208. if (!c.Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    209. {
    210. Face3D frontFace = c.Faces.First(f => f.Color != Color.Black);
    211. Cube3D.RubikPosition frontSlice = FacePosToCubePos(frontFace.Position);
    212. Face3D face = c.Faces.First(f => f.Color != Color.Black && f.Color != frontFace.Color);
    213. Cube3D.RubikPosition slice = FacePosToCubePos(face.Position);
    215. Manager.Rotate90Sync(slice, true);
    216. if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    217. {
    218. Manager.Rotate90Sync(slice, false);
    219. //Algorithm to the right: U R Ui Ri Ui Fi U F
    220. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    221. Manager.Rotate90Sync(slice, true);
    222. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    223. Manager.Rotate90Sync(slice, false);
    224. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    225. Manager.Rotate90Sync(frontSlice, false);
    226. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    227. Manager.Rotate90Sync(frontSlice, true);
    228. }
    229. else
    230. {
    231. Manager.Rotate90Sync(slice, false);
    232. //Algorithm to the left: Ui Li U L U F Ui Fi
    233. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    234. Manager.Rotate90Sync(slice, false);
    235. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    236. Manager.Rotate90Sync(slice, true);
    237. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    238. Manager.Rotate90Sync(frontSlice, true);
    239. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    240. Manager.Rotate90Sync(frontSlice, false);
    241. }
    242. }
    244. //Rotate to start position for the algorithm
    245. IEnumerable<Cube3D> middles = Manager.RubikCube.cubes.Where(cu => Cube3D.isCenter(cu.Position)).Where(m => m.Colors.First(co => co != Color.Black)
    246. == RefreshCube(c).Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top).Color &&
    247. RemoveFlag(m.Position,Cube3D.RubikPosition.MiddleLayer) == RemoveFlag(RefreshCube(c).Position, Cube3D.RubikPosition.TopLayer));
    249. while (middles.Count() < 1)
    250. {
    251. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    252. middles = Manager.RubikCube.cubes.Where(cu => Cube3D.isCenter(cu.Position)).Where(m => m.Colors.First(co => co != Color.Black)
    253. == RefreshCube(c).Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top).Color &&
    254. RemoveFlag(m.Position, Cube3D.RubikPosition.MiddleLayer) == RemoveFlag(RefreshCube(c).Position, Cube3D.RubikPosition.TopLayer));
    255. }
    257. //Rotate to target position
    258. Face3D frontFac = RefreshCube(c).Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top);
    259. Cube3D.RubikPosition frontSlic = FacePosToCubePos(frontFac.Position);
    260. Cube3D.RubikPosition slic = Cube3D.RubikPosition.None;
    261. foreach (Cube3D.RubikPosition p in GetFlags(targetPosition))
    262. {
    263. if (p != Cube3D.RubikPosition.MiddleLayer && p!= frontSlic)
    264. slic |= p;
    265. }
    267. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    268. if (!RefreshCube(c).Position.HasFlag(slic))
    269. {
    270. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    271. //Algorithm to the right: U R Ui Ri Ui Fi U F
    272. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    273. Manager.Rotate90Sync(slic, true);
    274. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    275. Manager.Rotate90Sync(slic, false);
    276. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    277. Manager.Rotate90Sync(frontSlic, false);
    278. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    279. Manager.Rotate90Sync(frontSlic, true);
    280. }
    281. else
    282. {
    283. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    284. //Algorithm to the left: Ui Li U L U F Ui Fi
    285. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    286. Manager.Rotate90Sync(slic, false);
    287. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    288. Manager.Rotate90Sync(slic, true);
    289. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    290. Manager.Rotate90Sync(frontSlic, true);
    291. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    292. Manager.Rotate90Sync(frontSlic, false);
    293. }
    294. }
    295. }
    296. }
    298. private void SolveCrossTopLayer()
    299. {
    300. //Step 1: Get the color of the top layer to start with cross on the last layer
    301. Color topColor = Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top);
    303. //Step 2: Get edges with the color of the top face
    304. IEnumerable<Cube3D> topEdges = Manager.RubikCube.cubes.Where(c => Cube3D.isEdge(c.Position)).Where(c => c.Colors.Count(co => co == topColor) == 1);
    306. //Step 3: Solve the cross on the top layer
    307. while (topEdges.Where(c => c.Faces.First(f => f.Position == Face3D.FacePosition.Top).Color == topColor).Count() < 4)
    308. {
    309. if (topEdges.Where(c => c.Faces.First(f => f.Position == Face3D.FacePosition.Top).Color == topColor).Count() != 0)
    310. {
    311. while ((Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.LeftSlice | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top) != topColor))
    312. {
    313. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    314. }
    315. }
    316. if (Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.FrontSlice | Cube3D.RubikPosition.MiddleSlice_Sides, Face3D.FacePosition.Top) == topColor)
    317. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    319. Manager.Rotate90Sync(Cube3D.RubikPosition.FrontSlice, true);
    320. Manager.Rotate90Sync(Cube3D.RubikPosition.RightSlice, true);
    321. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    322. Manager.Rotate90Sync(Cube3D.RubikPosition.RightSlice, false);
    323. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    324. Manager.Rotate90Sync(Cube3D.RubikPosition.FrontSlice, false);
    326. topEdges = Manager.RubikCube.cubes.Where(c => Cube3D.isEdge(c.Position)).Where(c => c.Colors.Count(co => co == topColor) == 1);
    327. }
    329. //Step 4: Move the edges of the cross to their target positions
    330. while (topEdges.Where(c => c.Position == GetTargetPosition(c)).Count() < 4)
    331. {
    332. IEnumerable<Cube3D> correctEdges = topEdges.Where(c => c.Position == GetTargetPosition(c));
    333. while (correctEdges.Count() < 2)
    334. {
    335. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    336. correctEdges = correctEdges.Select(cE => RefreshCube(cE));
    337. }
    339. Cube3D.RubikPosition rightSlice = FacePosToCubePos(correctEdges.First().Faces
    340. .First(f => f.Color != topColor && f.Color != Color.Black).Position);
    341. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    342. correctEdges = correctEdges.Select(cE => RefreshCube(cE));
    344. if (correctEdges.Count(c => c.Position.HasFlag(rightSlice)) == 0)
    345. {
    346. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    347. }
    348. else
    349. {
    350. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    351. correctEdges = correctEdges.Select(cE => RefreshCube(cE));
    352. rightSlice = FacePosToCubePos(correctEdges.First(cE => !cE.Position.HasFlag(rightSlice)).Faces
    353. .First(f => f.Color != topColor && f.Color != Color.Black).Position);
    354. }
    355. //Algorithm: R U Ri U R U U Ri
    356. Manager.Rotate90Sync(rightSlice, true);
    357. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    358. Manager.Rotate90Sync(rightSlice, false);
    359. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    360. Manager.Rotate90Sync(rightSlice, true);
    361. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    362. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    363. Manager.Rotate90Sync(rightSlice, false);
    365. topEdges = topEdges.Select(tE => RefreshCube(tE));
    366. while (correctEdges.Count() < 2)
    367. {
    368. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    369. correctEdges = correctEdges.Select(cE => RefreshCube(cE));
    370. }
    371. }
    372. }
    374. private void CompleteLastLayer()
    375. {
    376. //Step 1: Get the color of the top layer to start with cross on the last layer
    377. Color topColor = Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top);
    379. //Step 2: Get edges with the color of the top face
    380. IEnumerable<Cube3D> topCorners = Manager.RubikCube.cubes.Where(c => Cube3D.isCorner(c.Position)).Where(c => c.Position.HasFlag(Cube3D.RubikPosition.TopLayer));
    382. //Step 3: Bring corners to their target position
    383. while (topCorners.Where(c => c.Position == GetTargetPosition(c)).Count() < 4)
    384. {
    385. IEnumerable<Cube3D> correctCorners = topCorners.Where(c => c.Position == GetTargetPosition(c));
    386. Cube3D.RubikPosition rightSlice;
    387. if (correctCorners.Count() != 0)
    388. {
    389. Cube3D firstCube = correctCorners.First();
    390. Face3D rightFace = firstCube.Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top);
    391. rightSlice = FacePosToCubePos(rightFace.Position);
    392. Manager.Rotate90Sync(rightSlice, true);
    393. if (RefreshCube(firstCube).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    394. {
    395. Manager.Rotate90Sync(rightSlice, false);
    396. }
    397. else
    398. {
    399. Manager.Rotate90Sync(rightSlice, false);
    400. rightSlice = FacePosToCubePos(firstCube.Faces.First(f => f.Color != rightFace.Color && f.Color != Color.Black && f.Position != Face3D.FacePosition.Top).Position);
    401. }
    402. }
    403. else rightSlice = Cube3D.RubikPosition.RightSlice;
    405. Cube3D.RubikPosition leftSlice = GetOppositeFace(rightSlice);
    406. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    407. Manager.Rotate90Sync(rightSlice, true);
    408. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    409. Manager.Rotate90Sync(leftSlice, false);
    410. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    411. Manager.Rotate90Sync(rightSlice, false);
    412. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, false);
    413. Manager.Rotate90Sync(leftSlice, true);
    414. topCorners = topCorners.Select(tC => RefreshCube(tC));
    415. correctCorners = correctCorners.Select(cC => RefreshCube(cC));
    416. }
    418. //Step 4: Orientation of the corners on the top layer
    419. topCorners = topCorners.Select(tC => RefreshCube(tC));
    422. Face3D rightFac = RefreshCube(topCorners.First()).Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top);
    423. Cube3D.RubikPosition rightSlic = FacePosToCubePos(rightFac.Position);
    424. Manager.Rotate90Sync(rightSlic, true);
    425. if (RefreshCube(topCorners.First()).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    426. {
    427. Manager.Rotate90Sync(rightSlic, false);
    428. }
    429. else
    430. {
    431. Manager.Rotate90Sync(rightSlic, false);
    432. rightSlic = FacePosToCubePos(topCorners.First().Faces.First(f => f.Color != rightFac.Color && f.Color != Color.Black && f.Position != Face3D.FacePosition.Top).Position);
    433. }
    435. foreach (Cube3D c in topCorners)
    436. {
    437. while (!RefreshCube(c).Position.HasFlag(rightSlic))
    438. {
    439. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    440. }
    441. Manager.Rotate90Sync(rightSlic, true);
    442. if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
    443. {
    444. Manager.Rotate90Sync(rightSlic, false);
    445. }
    446. else
    447. {
    448. Manager.Rotate90Sync(rightSlic, false);
    449. Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    450. }
    452. //Algorithm: Ri Di R D
    453. while (RefreshCube(c).Faces.First(f => f.Position == Face3D.FacePosition.Top).Color != topColor)
    454. {
    455. Manager.Rotate90Sync(rightSlic, false);
    456. Manager.Rotate90Sync(Cube3D.RubikPosition.BottomLayer, false);
    457. Manager.Rotate90Sync(rightSlic, true);
    458. Manager.Rotate90Sync(Cube3D.RubikPosition.BottomLayer, true);
    459. }
    460. }
    462. topCorners = topCorners.Select(tC => RefreshCube(tC));
    463. while (topCorners.Count(tC => tC.Position == GetTargetPosition(tC)) != 4) Manager.Rotate90Sync(Cube3D.RubikPosition.TopLayer, true);
    464. }
    466. private Cube3D.RubikPosition FacePosToCubePos(Face3D.FacePosition position)
    467. {
    468. switch (position)
    469. {
    470. case Face3D.FacePosition.Top:
    471. return Cube3D.RubikPosition.TopLayer;
    472. case Face3D.FacePosition.Bottom:
    473. return Cube3D.RubikPosition.BottomLayer;
    474. case Face3D.FacePosition.Left:
    475. return Cube3D.RubikPosition.LeftSlice;
    476. case Face3D.FacePosition.Right:
    477. return Cube3D.RubikPosition.RightSlice;
    478. case Face3D.FacePosition.Back:
    479. return Cube3D.RubikPosition.BackSlice;
    480. case Face3D.FacePosition.Front:
    481. return Cube3D.RubikPosition.FrontSlice;
    482. default:
    483. return Cube3D.RubikPosition.None;
    484. }
    485. }
    487. private Cube3D.RubikPosition RemoveFlag(Cube3D.RubikPosition oldPosition, Cube3D.RubikPosition item)
    488. {
    489. return oldPosition &= ~item;
    490. }
    492. private Cube3D.RubikPosition GetTargetPosition(Cube3D cube)
    493. {
    494. return standardCube.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, cube.Colors)).Position;
    495. }
    497. private Cube3D RefreshCube(Cube3D cube)
    498. {
    499. return Manager.RubikCube.cubes.First(cu => ScrambledEquals(cu.Colors, cube.Colors));
    500. }
    502. private Cube3D.RubikPosition GetOppositeFace(Cube3D.RubikPosition layer)
    503. {
    504. switch (layer)
    505. {
    506. case Cube3D.RubikPosition.TopLayer:
    507. return Cube3D.RubikPosition.BottomLayer;
    508. case Cube3D.RubikPosition.BottomLayer:
    509. return Cube3D.RubikPosition.TopLayer;
    510. case Cube3D.RubikPosition.FrontSlice:
    511. return Cube3D.RubikPosition.BackSlice;
    512. case Cube3D.RubikPosition.BackSlice:
    513. return Cube3D.RubikPosition.FrontSlice;
    514. case Cube3D.RubikPosition.LeftSlice:
    515. return Cube3D.RubikPosition.RightSlice;
    516. case Cube3D.RubikPosition.RightSlice:
    517. return Cube3D.RubikPosition.LeftSlice;
    518. default:
    519. return Cube3D.RubikPosition.None;
    520. }
    521. }
    523. static IEnumerable<Enum> GetFlags(Enum input)
    524. {
    525. foreach (Enum value in Enum.GetValues(input.GetType()))
    526. if (input.HasFlag(value))
    527. yield return value;
    528. }
    530. private static bool ScrambledEquals<T>(IEnumerable<T> list1, IEnumerable<T> list2)
    531. {
    532. var cnt = new Dictionary<T, int>();
    533. foreach (T s in list1)
    534. {
    535. if (cnt.ContainsKey(s))
    536. {
    537. cnt[s]++;
    538. }
    539. else
    540. {
    541. cnt.Add(s, 1);
    542. }
    543. }
    544. foreach (T s in list2)
    545. {
    546. if (cnt.ContainsKey(s))
    547. {
    548. cnt[s]--;
    549. }
    550. else
    551. {
    552. return false;
    553. }
    554. }
    555. return cnt.Values.All(c => c == 0);
    556. }
    557. }
    558. }


    Jetzt noch eine andere Frage:
    Ich würde gerne für die Eingabe eines ungelösten Cubes eine Webcam verwenden und die Farben mit einem aufgenommenen Bild von der Webcam festlegen, um somit mühselige Eingabearbeit zu ersparen. Wie kann ich das verwirklichen?

    Vielen Dank
    Switcherlapp97
    RubiksCubeSolver


    Jetzt im Showroom

Facebook