private void RotateSidesCounterClockWise(RubiksFace toRotate)
{
RubiksFace topLinkedFace = m_rubiksData[toRotate.LinkedColorTop];
RubiksFace rightLinkedFace = m_rubiksData[toRotate.LinkedColorRight];
RubiksFace leftLinkedFace = m_rubiksData[toRotate.LinkedColorLeft];
RubiksFace bottomLinkedFace = m_rubiksData[toRotate.LinkedColorBottom];
RubiksPosition[] topLinkedPositions = GetTopLinkedPositions(toRotate.Color);
RubiksPosition[] leftLinkedPositions = GetLeftLinkedPositions(toRotate.Color);
RubiksPosition[] bottomLinkedPositions = GetBottomLinkedPositions(toRotate.Color);
RubiksPosition[] rightLinkedPositions = GetRightLinkedPositions(toRotate.Color);
RubiksColor tempTopLinkedFirstColor = topLinkedFace.GetColor(topLinkedPositions[0]);
RubiksColor tempTopLinkedSecondColor = topLinkedFace.GetColor(topLinkedPositions[1]);
RubiksColor tempTopLinkedThirdColor = topLinkedFace.GetColor(topLinkedPositions[2]);
topLinkedFace.Face[topLinkedPositions[0]] = rightLinkedFace.GetColor(rightLinkedPositions[0]);
topLinkedFace.Face[topLinkedPositions[1]] = rightLinkedFace.GetColor(rightLinkedPositions[1]);
topLinkedFace.Face[topLinkedPositions[2]] = rightLinkedFace.GetColor(rightLinkedPositions[2]);
rightLinkedFace.Face[rightLinkedPositions[0]] = bottomLinkedFace.GetColor(bottomLinkedPositions[0]);
rightLinkedFace.Face[rightLinkedPositions[1]] = bottomLinkedFace.GetColor(bottomLinkedPositions[1]);
rightLinkedFace.Face[rightLinkedPositions[2]] = bottomLinkedFace.GetColor(bottomLinkedPositions[2]);
bottomLinkedFace.Face[bottomLinkedPositions[0]] = leftLinkedFace.GetColor(leftLinkedPositions[0]);
bottomLinkedFace.Face[bottomLinkedPositions[1]] = leftLinkedFace.GetColor(leftLinkedPositions[1]);
bottomLinkedFace.Face[bottomLinkedPositions[2]] = leftLinkedFace.GetColor(leftLinkedPositions[2]);
leftLinkedFace.Face[leftLinkedPositions[0]] = tempTopLinkedFirstColor;
leftLinkedFace.Face[leftLinkedPositions[1]] = tempTopLinkedSecondColor;
leftLinkedFace.Face[leftLinkedPositions[2]] = tempTopLinkedThirdColor;
}
private string SolveTopEdges(RubiksColor[,] rubiks)
{
StringBuilder topEdgesSolve = new StringBuilder();
for (int i = 0; i < 4; i++)
{
RubiksColor targetFront = rubiks[4, 4];
if (rubiks[5, 1] == targetFront)
{
topEdgesSolve.Append(DoMoves("R U R' U R U2 R' U", rubiks));
}
else if (rubiks[3, 3] == targetFront)
{
topEdgesSolve.Append(DoMoves("Ro R U R' U R U2 R' U", rubiks));
}
else if (rubiks[7, 0] == targetFront)
{
topEdgesSolve.Append(DoMoves("R U R' U R U2 R' U Ro Ro Ro R U R' U R U2 R' U Ro R U R' U R U2 R' U ", rubiks));
}
topEdgesSolve.Append(DoMoves("Ro", rubiks));
}
if (rubiks[1, 4] != rubiks[4, 4] || rubiks[5, 1] != rubiks[4, 1] || rubiks[7, 0] != rubiks[4, 0] || rubiks[3, 3] != rubiks[4, 3])
{
throw new RubiksCubeUnsolvableException();
}
topEdgesSolve.Append(" ");
return(topEdgesSolve.ToString());
}
/// <summary>
/// Sets the view of the cube.
/// </summary>
/// <param name="front">The color of the front face.</param>
/// <param name="up">The color of the up face.</param>
public void SetView(RubiksColor front, RubiksColor up)
{
Cubie centerWithFrontColor = FindCenter(front);
// Rotates the cube until the center reaches the front face.
if (centerWithFrontColor.Y == 1)
{
while (centerWithFrontColor.Z != 0)
{
RotateCubiesAroundAxis(_cubies, Axis.Y, false);
}
}
else
{
while (centerWithFrontColor.Z != 0)
{
RotateCubiesAroundAxis(_cubies, Axis.X, false);
}
}
// Rotates the cube until the center reaches the up face.
while (FindCubie(1, 0, 1).UpColor != up)
{
RotateCubiesAroundAxis(_cubies, Axis.Z, false);
}
}
private void FillRubiksOppositeColor(RubiksColor color)
{
RubiksColor oppositeColor = RubiksColor.NONE;
switch (color)
{
case RubiksColor.BLUE:
oppositeColor = RubiksColor.GREEN;
break;
case RubiksColor.GREEN:
oppositeColor = RubiksColor.BLUE;
break;
case RubiksColor.YELLOW:
oppositeColor = RubiksColor.WHITE;
break;
case RubiksColor.WHITE:
oppositeColor = RubiksColor.YELLOW;
break;
case RubiksColor.RED:
oppositeColor = RubiksColor.ORANGE;
break;
case RubiksColor.ORANGE:
oppositeColor = RubiksColor.RED;
break;
default: break;
}
m_rubiksOppositeColor[color] = oppositeColor;
}
private string SolveOrientCorners(RubiksColor[,] rubiks)
{
StringBuilder orientCornersSolve = new StringBuilder();
RubiksColor targetTop = rubiks[4, 2];
for (int i = 0; i < 4; i++)
{
int rotation = 0;
while (rubiks[8, 2] != targetTop)
{
orientCornersSolve.Append(DoMoves("R' D' R D", rubiks));
if (rotation > 4)
{
throw new RubiksCubeUnsolvableException();
}
rotation++;
}
orientCornersSolve.Append(DoMoves("U", rubiks));
}
while (rubiks[1, 4] != rubiks[4, 4])
{
orientCornersSolve.Append(DoMoves("U", rubiks));
}
return(orientCornersSolve.ToString());
}
private string SolvePermutateCorners(RubiksColor[,] rubiks)
{
StringBuilder permutateCornersSolve = new StringBuilder();
RubiksColor targetFront = rubiks[4, 4];
RubiksColor targetTop = rubiks[4, 2];
RubiksColor targetRight = rubiks[4, 3];
bool correctCornerFound = false;
int tests = 0;
while (!correctCornerFound)
{
correctCornerFound = true;
for (int i = 0; i < 4; i++)
{
targetFront = rubiks[4, 4];
targetTop = rubiks[4, 2];
targetRight = rubiks[4, 3];
if (rubiks[8, 2] == targetTop && rubiks[6, 3] == targetRight && rubiks[2, 4] == targetFront)
{
break;
}
else if (rubiks[6, 3] == targetTop && rubiks[2, 4] == targetRight && rubiks[8, 2] == targetFront)
{
break;
}
else if (rubiks[2, 4] == targetTop && rubiks[8, 2] == targetRight && rubiks[6, 3] == targetFront)
{
break;
}
if (i == 3)
{
correctCornerFound = false;
permutateCornersSolve.Append(DoMoves("U R U' L' U R' U' L", rubiks));
break;
}
permutateCornersSolve.Append(DoMoves("Ro", rubiks));
}
if (tests > 3)
{
throw new RubiksCubeUnsolvableException();
}
tests++;
}
RubiksColor targetLeft = rubiks[4, 1];
int ggr = 0;
while (!(new RubiksColor[] { rubiks[6, 2], rubiks[8, 1], rubiks[0, 4] }.Contains(targetFront) && new RubiksColor[] { rubiks[6, 2], rubiks[8, 1], rubiks[0, 4] }.Contains(targetLeft)))
{
permutateCornersSolve.Append(DoMoves("U R U' L' U R' U' L", rubiks));
if (ggr > 1)
{
throw new RubiksCubeUnsolvableException();
}
ggr++;
}
permutateCornersSolve.Append(" ");
return(permutateCornersSolve.ToString());
}
private RubiksColor[,] ReadRubiksColors(RubiksCube rubiks, Color[] repClr)
{
//Läs in färger
RubiksColor[,] cube = new RubiksColor[9, 6];
CubeSide sideToRead = CubeSide.Back;
for (int i = 0; i < 6; i++)
{
Color[] clrs = rubiks.GetCubeSideColors(sideToRead);
switch (sideToRead)
{
case CubeSide.Front:
Flip(clrs);
RotateClock(clrs);
RotateClock(clrs);
RotateClock(clrs);
sideToRead = CubeSide.Bottom;
break;
case CubeSide.Right:
Flip(clrs);
RotateClock(clrs);
RotateClock(clrs);
RotateClock(clrs);
sideToRead = CubeSide.Front;
break;
case CubeSide.Top:
Flip(clrs);
RotateClock(clrs);
RotateClock(clrs);
RotateClock(clrs);
sideToRead = CubeSide.Right;
break;
case CubeSide.Left:
RotateClock(clrs);
RotateClock(clrs);
RotateClock(clrs);
sideToRead = CubeSide.Top;
break;
case CubeSide.Back:
RotateClock(clrs);
sideToRead = CubeSide.Left;
break;
case CubeSide.Bottom:
RotateClock(clrs);
break;
}
for (int j = 0; j < 9; j++)
{
cube[j, i] = (RubiksColor)((int)Array.FindIndex(repClr, x => x.R == clrs[j].R && x.G == clrs[j].G && x.B == clrs[j].B));
}
}
return(cube);
}
public bool CheckFace(RubiksColor faceColor)
{
foreach (RubiksColor color in Face.Values)
{
if (color != faceColor)
{
return(false);
}
}
return(true);
}
public void RotateFaceCounterClockWise(RubiksColor faceColor)
{
RubiksFace toRotate = m_rubiksData[faceColor];
toRotate.RotateFaceCounterClockWise();
RotateSidesCounterClockWise(toRotate);
#if UNITY_EDITOR || DEVELOPMENT_BUILD
Debug.Log(this.ToString());
#endif
}
/// <summary>
/// Returns the center with the specified color, if existing.
/// </summary>
/// <param name="color">The color.</param>
/// <returns>The center.</returns>
public Cubie FindCenter(RubiksColor color)
{
foreach (Cubie c in Centers)
{
if (c.Colors.Contains(color))
{
return(c);
}
}
return(null);
}
/// <summary>
/// Returns the edge with the specified colors, if existing.
/// </summary>
/// <param name="color1">The first color.</param>
/// <param name="color2">The second color.</param>
/// <returns>The edge.</returns>
public Cubie FindEdge(RubiksColor color1, RubiksColor color2)
{
foreach (Cubie c in Edges)
{
if (c.Colors.Contains(color1) && c.Colors.Contains(color2))
{
return(c);
}
}
return(null);
}
/// <summary>
/// Returns the corner with the specified colors, if existing.
/// </summary>
/// <param name="color1">The first color.</param>
/// <param name="color2">The second color.</param>
/// <param name="color3">The third color.</param>
/// <returns>The corner.</returns>
public Cubie FindCorner(RubiksColor color1, RubiksColor color2, RubiksColor color3)
{
foreach (Cubie c in Corners)
{
if (c.Colors.Contains(color1) && c.Colors.Contains(color2) && c.Colors.Contains(color3))
{
return(c);
}
}
return(null);
}
protected void ChangeFacesOnRotation(RotationDirection direction)
{
RubiksColor currentLeftFaceColor = m_rubiksCubeManager.LeftFaceColor;
RubiksColor currentRightFaceColor = m_rubiksCubeManager.RightFaceColor;
RubiksColor currentUpFaceColor = m_rubiksCubeManager.UpFaceColor;
RubiksColor currentOppositeLeftFaceColor = m_rubiksCubeManager.Logic.RubiksOppositeColor[currentLeftFaceColor];
RubiksColor currentOppositeRightFaceColor = m_rubiksCubeManager.Logic.RubiksOppositeColor[currentRightFaceColor];
RubiksColor currentOppositeUpFaceColor = m_rubiksCubeManager.Logic.RubiksOppositeColor[currentUpFaceColor];
RubiksColor nextLeftFaceColor = RubiksColor.NONE;
RubiksColor nextRightFaceColor = RubiksColor.NONE;
RubiksColor nextUpFaceColor = RubiksColor.NONE;
switch (direction)
{
case RotationDirection.UP:
nextLeftFaceColor = currentOppositeUpFaceColor;
nextRightFaceColor = currentRightFaceColor;
nextUpFaceColor = currentLeftFaceColor;
break;
case RotationDirection.DOWN:
nextLeftFaceColor = currentUpFaceColor;
nextRightFaceColor = currentRightFaceColor;
nextUpFaceColor = currentOppositeLeftFaceColor;
break;
case RotationDirection.RIGHT:
nextLeftFaceColor = currentOppositeRightFaceColor;
nextRightFaceColor = currentLeftFaceColor;
nextUpFaceColor = currentUpFaceColor;
break;
case RotationDirection.LEFT:
nextLeftFaceColor = currentRightFaceColor;
nextRightFaceColor = currentOppositeLeftFaceColor;
nextUpFaceColor = currentUpFaceColor;
break;
default: break;
}
m_rubiksCubeManager.LeftFaceColor = nextLeftFaceColor;
m_rubiksCubeManager.RightFaceColor = nextRightFaceColor;
m_rubiksCubeManager.UpFaceColor = nextUpFaceColor;
#if UNITY_EDITOR || DEVELOPMENT_BUILD
Debug.Log($"Transitioning: Left color {currentLeftFaceColor} -> {nextLeftFaceColor}");
Debug.Log($"Transitioning: Right color {currentRightFaceColor} -> {nextRightFaceColor}");
Debug.Log($"Transitioning: Up color {currentUpFaceColor} -> {nextUpFaceColor}");
#endif
}
public RubiksFace(RubiksColor faceColor)
{
m_color = faceColor;
SetSidesLinkedColor(faceColor);
for (int i = 0; i < CUBE_HEIGHT; i++)
{
for (int j = 0; j < CUBE_WIDTH; j++)
{
m_face[GetPositionFromCoordinates(i, j)] = faceColor;
}
}
}
private void SetSidesLinkedColor(RubiksColor faceColor)
{
switch (faceColor)
{
case RubiksColor.GREEN:
m_linkedColorTop = RubiksColor.ORANGE;
m_linkedColorRight = RubiksColor.WHITE;
m_linkedColorLeft = RubiksColor.YELLOW;
m_linkedColorBottom = RubiksColor.RED;
break;
case RubiksColor.BLUE:
m_linkedColorTop = RubiksColor.ORANGE;
m_linkedColorRight = RubiksColor.YELLOW;
m_linkedColorLeft = RubiksColor.WHITE;
m_linkedColorBottom = RubiksColor.RED;
break;
case RubiksColor.ORANGE:
m_linkedColorTop = RubiksColor.YELLOW;
m_linkedColorRight = RubiksColor.BLUE;
m_linkedColorLeft = RubiksColor.GREEN;
m_linkedColorBottom = RubiksColor.WHITE;
break;
case RubiksColor.RED:
m_linkedColorTop = RubiksColor.WHITE;
m_linkedColorRight = RubiksColor.BLUE;
m_linkedColorLeft = RubiksColor.GREEN;
m_linkedColorBottom = RubiksColor.YELLOW;
break;
case RubiksColor.WHITE:
m_linkedColorTop = RubiksColor.ORANGE;
m_linkedColorRight = RubiksColor.BLUE;
m_linkedColorLeft = RubiksColor.GREEN;
m_linkedColorBottom = RubiksColor.RED;
break;
case RubiksColor.YELLOW:
m_linkedColorTop = RubiksColor.ORANGE;
m_linkedColorRight = RubiksColor.GREEN;
m_linkedColorLeft = RubiksColor.BLUE;
m_linkedColorBottom = RubiksColor.RED;
break;
default:
Debug.LogError("Should not access default of switch");
break;
}
}
public void RotateFaceCounterClockWise()
{
RubiksColor tempTopLeftColor = m_face[RubiksPosition.TOPLEFT];
RubiksColor tempLeftColor = m_face[RubiksPosition.LEFT];
m_face[RubiksPosition.TOPLEFT] = m_face[RubiksPosition.TOPRIGHT];
m_face[RubiksPosition.TOPRIGHT] = m_face[RubiksPosition.BOTTOMRIGHT];
m_face[RubiksPosition.BOTTOMRIGHT] = m_face[RubiksPosition.BOTTOMLEFT];
m_face[RubiksPosition.BOTTOMLEFT] = tempTopLeftColor;
m_face[RubiksPosition.LEFT] = m_face[RubiksPosition.TOP];
m_face[RubiksPosition.TOP] = m_face[RubiksPosition.RIGHT];
m_face[RubiksPosition.RIGHT] = m_face[RubiksPosition.BOTTOM];
m_face[RubiksPosition.BOTTOM] = tempLeftColor;
}
private void OnRotationFinished(RubiksColor color, FaceRotation direction)
{
if (color != RubiksColor.NONE)
{
if (direction == FaceRotation.CLOCKWISE)
{
m_rubiksLogic.RotateFaceClockWise(color);
}
else if (direction == FaceRotation.COUNTERCLOCKWISE)
{
m_rubiksLogic.RotateFaceCounterClockWise(color);
}
}
}
private string SolveTopCross(RubiksColor[,] rubiks)
{
StringBuilder topCrossSolve = new StringBuilder();
RubiksColor topTargetColor = rubiks[4, 2];
for (int i = 0; i < 4; i++)
{
int[] top = new int[9];
for (int j = 0; j < 9; j++)
{
if (rubiks[j, 2] == topTargetColor && new int[] { 1, 3, 4, 5, 7 }.Contains(j))
{
top[j] = 1;
}
else
{
top[j] = 0;
}
}
if (top.SequenceEqual(new int[] { 0, 0, 0, 0, 1, 0, 0, 0, 0 }))
{
topCrossSolve.Append(DoMoves("F R U R' U' F' U2 F R U R' U' R U R' U' F'", rubiks));
}
else if (top.SequenceEqual(new int[] { 0, 1, 0, 1, 1, 0, 0, 0, 0 }))
{
topCrossSolve.Append(DoMoves("F R U R' U' R U R' U' F'", rubiks));
}
else if (top.SequenceEqual(new int[] { 0, 0, 0, 1, 1, 1, 0, 0, 0 }))
{
topCrossSolve.Append(DoMoves("F R U R' U' F'", rubiks));
}
else if (top.SequenceEqual(new int[] { 0, 1, 0, 1, 1, 1, 0, 1, 0 }))
{
break;
}
else
{
topCrossSolve.Append(DoMoves("Ro", rubiks));
continue;
}
break;
}
if (new RubiksColor[] { rubiks[1, 2], rubiks[3, 2], rubiks[5, 2], rubiks[7, 2] }.Any(x => x != topTargetColor))
{
throw new RubiksCubeUnsolvableException();
}
return(topCrossSolve.ToString());
}
public void ParseSequence(string actionSequence)
{
m_colors.Clear();
m_directions.Clear();
string[] sequenceElements = actionSequence.Split('_');
for (int i = 0; i < sequenceElements.Length; i++)
{
if (sequenceElements[i].Length == 0)
{
continue;
}
RubiksColor faceColor = RubiksColor.NONE;
switch (sequenceElements[i][0])
{
case 'W':
faceColor = RubiksColor.WHITE;
break;
case 'Y':
faceColor = RubiksColor.YELLOW;
break;
case 'B':
faceColor = RubiksColor.BLUE;
break;
case 'G':
faceColor = RubiksColor.GREEN;
break;
case 'R':
faceColor = RubiksColor.RED;
break;
case 'O':
faceColor = RubiksColor.ORANGE;
break;
default: break;
}
FaceRotation direction = sequenceElements[i][1] == 'C' ? FaceRotation.CLOCKWISE : FaceRotation.COUNTERCLOCKWISE;
m_colors.Add(faceColor);
m_directions.Add(direction);
}
}
private RubiksPosition[] GetRightLinkedPositions(RubiksColor color)
{
RubiksPosition[] rightLinkedCoords = new RubiksPosition[3];
switch (color)
{
case RubiksColor.WHITE:
rightLinkedCoords[0] = RubiksPosition.TOPLEFT;
rightLinkedCoords[1] = RubiksPosition.LEFT;
rightLinkedCoords[2] = RubiksPosition.BOTTOMLEFT;
break;
case RubiksColor.BLUE:
rightLinkedCoords[0] = RubiksPosition.TOPLEFT;
rightLinkedCoords[1] = RubiksPosition.LEFT;
rightLinkedCoords[2] = RubiksPosition.BOTTOMLEFT;
break;
case RubiksColor.YELLOW:
rightLinkedCoords[0] = RubiksPosition.TOPLEFT;
rightLinkedCoords[1] = RubiksPosition.LEFT;
rightLinkedCoords[2] = RubiksPosition.BOTTOMLEFT;
break;
case RubiksColor.GREEN:
rightLinkedCoords[0] = RubiksPosition.TOPLEFT;
rightLinkedCoords[1] = RubiksPosition.LEFT;
rightLinkedCoords[2] = RubiksPosition.BOTTOMLEFT;
break;
case RubiksColor.ORANGE:
rightLinkedCoords[0] = RubiksPosition.TOPRIGHT;
rightLinkedCoords[1] = RubiksPosition.TOP;
rightLinkedCoords[2] = RubiksPosition.TOPLEFT;
break;
case RubiksColor.RED:
rightLinkedCoords[0] = RubiksPosition.BOTTOMLEFT;
rightLinkedCoords[1] = RubiksPosition.BOTTOM;
rightLinkedCoords[2] = RubiksPosition.BOTTOMRIGHT;
break;
default:
Debug.LogError("Should not be here");
break;
}
return(rightLinkedCoords);
}
public SolvedPuzzleCubieConfigurator(RubiksColor frontColor = RubiksColor.White, RubiksColor backColor = RubiksColor.Yellow, RubiksColor rightColor = RubiksColor.Green, RubiksColor leftColor = RubiksColor.Blue, RubiksColor upColor = RubiksColor.Red, RubiksColor downColor = RubiksColor.Orange)
{
_frontColor = frontColor;
_backColor = backColor;
_rightColor = rightColor;
_leftColor = leftColor;
_upColor = upColor;
_downColor = downColor;
_cubieCreators = new Dictionary <RubiksDirection, Func <RelativePosition, Position, Cubie> >()
{
{ RubiksDirection.Front, CreateFrontCubie },
{ RubiksDirection.Back, CreateBackCubie },
{ RubiksDirection.Right, CreateRightCubie },
{ RubiksDirection.Left, CreateLeftCubie },
{ RubiksDirection.Up, CreateUpCubie },
{ RubiksDirection.Down, CreateDownCubie }
};
}
private void Rotate(RubiksFaceRotation.RubiksFace faceToRotate, RubiksColor faceColor, GameObject faceGO, FaceRotation direction)
{
m_rubiksFaceRotation.Rotate(faceToRotate, direction, faceGO, m_shuffleRotationDuration, OnRotationFinished);
}
/// <summary>
/// Initializes a new instance of the <see cref="CubeView"/> class.
/// </summary>
/// <param name="front">The front color.</param>
/// <param name="up">The up color.</param>
public CubeView(RubiksColor front, RubiksColor up)
{
FrontColor = front;
UpColor = up;
}
private string PrintColor(RubiksColor color)
{
return(Enum.GetName(typeof(RubiksColor), color)[0].ToString());
}
private string SolveCross(RubiksColor[,] rubiks)
{
StringBuilder crossSolve = new StringBuilder();
for (int i = 0; i < 4; i++)
{
RubiksColor targetTopColor = rubiks[4, 2];
RubiksColor targetFrontColor = rubiks[4, 4];
//4 övre kanter
if (rubiks[7, 2] == targetFrontColor && rubiks[1, 4] == targetTopColor)
{
crossSolve.Append(DoMoves("F U' R U", rubiks));
}
else if (rubiks[5, 2] == targetFrontColor && rubiks[3, 3] == targetTopColor)
{
crossSolve.Append(DoMoves("R' F'", rubiks));
}
else if (rubiks[1, 2] == targetFrontColor && rubiks[7, 0] == targetTopColor)
{
crossSolve.Append(DoMoves("U R' U' F'", rubiks));
}
else if (rubiks[3, 2] == targetFrontColor && rubiks[5, 1] == targetTopColor)
{
crossSolve.Append(DoMoves("L F", rubiks));
}
else if (rubiks[3, 3] == targetFrontColor && rubiks[5, 2] == targetTopColor)
{
crossSolve.Append(DoMoves("U F U' F'", rubiks));
}
else if (rubiks[7, 0] == targetFrontColor && rubiks[1, 2] == targetTopColor)
{
crossSolve.Append(DoMoves("U2 F U2 F'", rubiks));
}
else if (rubiks[5, 1] == targetFrontColor && rubiks[3, 2] == targetTopColor)
{
crossSolve.Append(DoMoves("U' F U F'", rubiks));
}
//4 mitten kanter
else if (rubiks[5, 4] == targetFrontColor && rubiks[7, 3] == targetTopColor)
{
crossSolve.Append(DoMoves("F'", rubiks));
}
else if (rubiks[7, 3] == targetFrontColor && rubiks[5, 4] == targetTopColor)
{
crossSolve.Append(DoMoves("U' R U", rubiks));
}
else if (rubiks[3, 4] == targetFrontColor && rubiks[7, 1] == targetTopColor)
{
crossSolve.Append(DoMoves("F", rubiks));
}
else if (rubiks[7, 1] == targetFrontColor && rubiks[3, 4] == targetTopColor)
{
crossSolve.Append(DoMoves("U L' U'", rubiks));
}
else if (rubiks[1, 1] == targetFrontColor && rubiks[3, 0] == targetTopColor)
{
crossSolve.Append(DoMoves("U L U'", rubiks));
}
else if (rubiks[3, 0] == targetFrontColor && rubiks[1, 1] == targetTopColor)
{
crossSolve.Append(DoMoves("U2 B' U2", rubiks));
}
else if (rubiks[5, 0] == targetFrontColor && rubiks[1, 3] == targetTopColor)
{
crossSolve.Append(DoMoves("U2 B U2", rubiks));
}
else if (rubiks[1, 3] == targetFrontColor && rubiks[5, 0] == targetTopColor)
{
crossSolve.Append(DoMoves("U' R' U", rubiks));
}
//4 undre kanter
else if (rubiks[7, 4] == targetFrontColor && rubiks[1, 5] == targetTopColor)
{
crossSolve.Append(DoMoves("F2", rubiks));
}
else if (rubiks[1, 5] == targetFrontColor && rubiks[7, 4] == targetTopColor)
{
crossSolve.Append(DoMoves("F U L' U'", rubiks));
}
else if (rubiks[5, 3] == targetFrontColor && rubiks[5, 5] == targetTopColor)
{
crossSolve.Append(DoMoves("U' R2 U", rubiks));
}
else if (rubiks[5, 5] == targetFrontColor && rubiks[5, 3] == targetTopColor)
{
crossSolve.Append(DoMoves("U' R U F'", rubiks));
}
else if (rubiks[3, 1] == targetFrontColor && rubiks[3, 5] == targetTopColor)
{
crossSolve.Append(DoMoves("U L2 U'", rubiks));
}
else if (rubiks[3, 5] == targetFrontColor && rubiks[3, 1] == targetTopColor)
{
crossSolve.Append(DoMoves("U L' U' F", rubiks));
}
else if (rubiks[1, 0] == targetFrontColor && rubiks[7, 5] == targetTopColor)
{
crossSolve.Append(DoMoves("D2 F2", rubiks));
}
else if (rubiks[7, 5] == targetFrontColor && rubiks[1, 0] == targetTopColor)
{
crossSolve.Append(DoMoves("D U L' U' F", rubiks));
}
if (rubiks[7, 2] == targetTopColor && rubiks[1, 4] == targetFrontColor)
{
if (i != 3)
{
crossSolve.Append(DoMoves("Ro", rubiks));
}
}
else
{
throw new RubiksCubeUnsolvableException();
}
}
crossSolve.Append(" ");
return(crossSolve.ToString());
}
private string SolveFirstLayer(RubiksColor[,] rubiks)
{
StringBuilder firstLayerSolve = new StringBuilder();
for (int i = 0; i < 4; i++)
{
RubiksColor targetTopColor = rubiks[4, 2];
RubiksColor targetRightColor = rubiks[4, 3];
RubiksColor targetFrontColor = rubiks[4, 4];
if (rubiks[2, 2] == targetTopColor && rubiks[8, 0] == targetRightColor && rubiks[0, 3] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R D2 R' D", rubiks));
}
else if (rubiks[0, 3] == targetTopColor && rubiks[2, 2] == targetRightColor && rubiks[8, 0] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R D2 R' D", rubiks));
}
else if (rubiks[8, 0] == targetTopColor && rubiks[0, 3] == targetRightColor && rubiks[2, 2] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R D2 R' D", rubiks));
}
else if (rubiks[2, 4] == targetTopColor && rubiks[8, 2] == targetRightColor && rubiks[6, 3] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R' D' R D", rubiks));
}
else if (rubiks[6, 3] == targetTopColor && rubiks[2, 4] == targetRightColor && rubiks[8, 2] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R' D' R D", rubiks));
}
else if (rubiks[0, 2] == targetTopColor && rubiks[2, 1] == targetRightColor && rubiks[6, 0] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("L' D2 L", rubiks));
}
else if (rubiks[2, 1] == targetTopColor && rubiks[6, 0] == targetRightColor && rubiks[0, 2] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("L' D2 L", rubiks));
}
else if (rubiks[6, 0] == targetTopColor && rubiks[0, 2] == targetRightColor && rubiks[2, 1] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("L' D2 L", rubiks));
}
else if (rubiks[8, 1] == targetTopColor && rubiks[6, 2] == targetRightColor && rubiks[0, 4] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("L D L'", rubiks));
}
else if (rubiks[0, 4] == targetTopColor && rubiks[8, 1] == targetRightColor && rubiks[6, 2] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("L D L'", rubiks));
}
else if (rubiks[6, 2] == targetTopColor && rubiks[0, 4] == targetRightColor && rubiks[8, 1] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("L D L'", rubiks));
}
else if (rubiks[6, 1] == targetTopColor && rubiks[6, 4] == targetRightColor && rubiks[0, 5] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D", rubiks));
}
else if (rubiks[0, 5] == targetTopColor && rubiks[6, 1] == targetRightColor && rubiks[6, 4] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D", rubiks));
}
else if (rubiks[6, 4] == targetTopColor && rubiks[0, 5] == targetRightColor && rubiks[6, 1] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D", rubiks));
}
else if (rubiks[0, 1] == targetTopColor && rubiks[6, 5] == targetRightColor && rubiks[0, 0] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D2", rubiks));
}
else if (rubiks[6, 5] == targetTopColor && rubiks[0, 0] == targetRightColor && rubiks[0, 1] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D2", rubiks));
}
else if (rubiks[0, 0] == targetTopColor && rubiks[0, 1] == targetRightColor && rubiks[6, 5] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D2", rubiks));
}
else if (rubiks[2, 0] == targetTopColor && rubiks[8, 5] == targetRightColor && rubiks[2, 3] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D'", rubiks));
}
else if (rubiks[8, 5] == targetTopColor && rubiks[2, 3] == targetRightColor && rubiks[2, 0] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D'", rubiks));
}
else if (rubiks[2, 3] == targetTopColor && rubiks[2, 0] == targetRightColor && rubiks[8, 5] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("D'", rubiks));
}
if (rubiks[8, 4] == targetTopColor && rubiks[8, 3] == targetRightColor && rubiks[2, 5] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("F D F'", rubiks));
}
else if (rubiks[8, 3] == targetTopColor && rubiks[2, 5] == targetRightColor && rubiks[8, 4] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R' D' R", rubiks));
}
else if (rubiks[2, 5] == targetTopColor && rubiks[8, 4] == targetRightColor && rubiks[8, 3] == targetFrontColor)
{
firstLayerSolve.Append(DoMoves("R' D2 R D R' D' R", rubiks));
}
if (rubiks[8, 2] == targetTopColor && rubiks[6, 3] == targetRightColor && rubiks[2, 4] == targetFrontColor)
{
if (i != 3)
{
firstLayerSolve.Append(DoMoves("Ro", rubiks));
}
}
else
{
Console.WriteLine(firstLayerSolve.ToString());
throw new RubiksCubeUnsolvableException();
}
}
firstLayerSolve.Append(" ");
return(firstLayerSolve.ToString());
}
private string SolveSecondLayer(RubiksColor[,] rubiks)
{
StringBuilder secondLayerSolve = new StringBuilder();
secondLayerSolve.Append(DoMoves("Tu Tu", rubiks));
for (int i = 0; i < 4; i++)
{
RubiksColor targetFrontColor = rubiks[4, 4];
RubiksColor targetRightColor = rubiks[4, 3];
if (rubiks[1, 4] == targetFrontColor && rubiks[7, 2] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[7, 2] == targetFrontColor && rubiks[1, 4] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U' Ro U' L' U L U F U' F'", rubiks));
}
else if (rubiks[3, 3] == targetFrontColor && rubiks[5, 2] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U U R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[5, 2] == targetFrontColor && rubiks[3, 3] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("Ro U' L' U L U F U' F'", rubiks));
}
else if (rubiks[7, 0] == targetFrontColor && rubiks[1, 2] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U2 U R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[1, 2] == targetFrontColor && rubiks[7, 0] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U Ro U' L' U L U F U' F'", rubiks));
}
else if (rubiks[5, 1] == targetFrontColor && rubiks[3, 2] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[3, 2] == targetFrontColor && rubiks[5, 1] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U2 Ro U' L' U L U F U' F'", rubiks));
}
else if (rubiks[7, 3] == targetFrontColor && rubiks[5, 4] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("R U' R' U' F' U F U' R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[3, 4] == targetFrontColor && rubiks[7, 1] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U' L' U L U F U' F' U Ro U' L' U L U F U' F'", rubiks));
}
else if (rubiks[7, 1] == targetFrontColor && rubiks[3, 4] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("U' L' U L U F U' F' U2 U R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[3, 0] == targetFrontColor && rubiks[1, 1] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("Ro Ro Ro U' L' U L U F U' F' Ro U U R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[1, 1] == targetFrontColor && rubiks[3, 0] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("Ro Ro Ro U' L' U L U F U' F' Ro Ro U' L' U L U F U' F'", rubiks));
}
else if (rubiks[5, 0] == targetFrontColor && rubiks[1, 3] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("Ro R U' R' U' F' U F Ro Ro Ro R U' R' U' F' U F Ro", rubiks));
}
else if (rubiks[1, 3] == targetFrontColor && rubiks[5, 0] == targetRightColor)
{
secondLayerSolve.Append(DoMoves("Ro R U' R' U' F' U F U2 U' L' U L U F U' F'", rubiks));
}
else
{
secondLayerSolve.Append(DoMoves("Ro", rubiks));
}
if (rubiks[3, 4] != targetRightColor || rubiks[7, 1] != targetFrontColor)
{
Console.WriteLine(secondLayerSolve.ToString());
throw new RubiksCubeUnsolvableException();
}
}
secondLayerSolve.Append(" ");
return(secondLayerSolve.ToString());
}
