/// <summary>
/// Returns the position of given cube where it has to be when the Rubik is solved
/// </summary>
/// <param name="cube">Defines the cube to be analyzed</param>
/// <returns></returns>
protected CubeFlag GetTargetFlags(Cube cube)
{
return(StandardCube.Cubes.First(cu => CollectionMethods.ScrambledEquals(cu.Colors, cube.Colors)).Position.Flags);
}
private Cube RefreshCube(Cube c)
{
return(Rubik.Cubes.First(cu => CollectionMethods.ScrambledEquals(cu.Colors, c.Colors)));
}
private void SolveFirstCross()
{
// Step 1: Get the edges with target position on the bottom layer
IEnumerable <Cube> bottomEdges = Rubik.Cubes.Where(c => c.IsEdge && GetTargetFlags(c).HasFlag(CubeFlag.BottomLayer));
// Step 2: Rotate a correct orientated edge of the bottom layer to target position
IEnumerable <Cube> solvedBottomEdges = bottomEdges.Where(bE => bE.Position.Flags == GetTargetFlags(bE) && bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom);
if (bottomEdges.Count(bE => bE.Position.HasFlag(CubeFlag.BottomLayer) && bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom) > 0)
{
while (solvedBottomEdges.Count() < 1)
{
SolverMove(CubeFlag.BottomLayer, true);
solvedBottomEdges = bottomEdges.Where(bE => bE.Position.Flags == GetTargetFlags(bE) && bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom);
}
}
// Step 3: Solve incorrect edges of the bottom layer
while (solvedBottomEdges.Count() < 4)
{
IEnumerable <Cube> unsolvedBottomEdges = bottomEdges.Except(solvedBottomEdges);
Cube e = (unsolvedBottomEdges.FirstOrDefault(c => c.Position.HasFlag(CubeFlag.TopLayer)) != null)
? unsolvedBottomEdges.FirstOrDefault(c => c.Position.HasFlag(CubeFlag.TopLayer)) : unsolvedBottomEdges.First();
Color secondColor = e.Colors.First(co => co != Rubik.BottomColor && co != Color.Black);
if (e.Position.Flags != GetTargetFlags(e))
{
// Rotate to top layer
CubeFlag layer = CubeFlagService.FromFacePosition(e.Faces.First(f => (f.Color == Rubik.BottomColor || f.Color == secondColor) &&
f.Position != FacePosition.Top && f.Position != FacePosition.Bottom).Position);
CubeFlag targetLayer = CubeFlagService.FromFacePosition(StandardCube.Cubes.First(cu => CollectionMethods.ScrambledEquals(cu.Colors, e.Colors))
.Faces.First(f => f.Color == secondColor).Position);
if (e.Position.HasFlag(CubeFlag.MiddleLayer))
{
if (layer == targetLayer)
{
while (!e.Position.HasFlag(CubeFlag.BottomLayer))
{
SolverMove(layer, true);
}
}
else
{
SolverMove(layer, true);
if (e.Position.HasFlag(CubeFlag.TopLayer))
{
SolverMove(CubeFlag.TopLayer, true);
SolverMove(layer, false);
}
else
{
for (int i = 0; i < 2; i++)
{
SolverMove(layer, true);
}
SolverMove(CubeFlag.TopLayer, true);
SolverMove(layer, true);
}
}
}
if (e.Position.HasFlag(CubeFlag.BottomLayer))
{
for (int i = 0; i < 2; i++)
{
SolverMove(layer, true);
}
}
// Rotate over target position
while (!e.Position.HasFlag(targetLayer))
{
SolverMove(CubeFlag.TopLayer, true);
}
//Rotate to target position
for (int i = 0; i < 2; i++)
{
SolverMove(targetLayer, true);
}
CubeFlag targetPos = GetTargetFlags(e);
}
// Flip the incorrect orientated edges with the algorithm: Fi D Ri Di
if (Solvability.GetOrientation(Rubik, e) != 0)
{
CubeFlag frontSlice = CubeFlagService.FromFacePosition(e.Faces.First(f => f.Color == Rubik.BottomColor).Position);
SolverMove(frontSlice, false);
SolverMove(CubeFlag.BottomLayer, true);
CubeFlag rightSlice = CubeFlagService.FromFacePosition(e.Faces.First(f => f.Color == secondColor).Position);
SolverMove(rightSlice, false);
SolverMove(CubeFlag.BottomLayer, false);
}
List <Face> faces = e.Faces.ToList();
solvedBottomEdges = bottomEdges.Where(bE => bE.Position.Flags == GetTargetFlags(bE) && bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom);
}
}
public static bool CorrectColors(Rubik r)
{
return(r.GenStandardCube().Cubes.Count(sc => r.Cubes
.Where(c => CollectionMethods.ScrambledEquals(c.Colors, sc.Colors)).Count() == 1) == r.Cubes.Count());
}
/// <summary>
/// True, if this pattern has exactly the same pattern elemnts as the other pattern
/// </summary>
/// <param name="pattern">Pattern to compare</param>
public bool Equals(Pattern pattern)
{
return(CollectionMethods.ScrambledEquals(pattern.Items, Items));
}
private void SolveFirstCross()
{
// Step 1: Get the edges with target position on the bottom layer
IEnumerable <Cube> bottomEdges =
Rubik.Cubes.Where(c =>
c.IsEdge
// target position on bottom layer
&& GetTargetFlags(c).HasFlag(CubeFlag.BottomLayer)
);
// Step 2: Rotate a correct orientated edge of the bottom layer to target position
IEnumerable <Cube> bottomEdgesInBottomLayerCorrectlyOriented =
bottomEdges.Where(bottomEdge =>
// is in bottom layer
bottomEdge.Position.Flags == GetTargetFlags(bottomEdge)
// is oriented correctly
&& bottomEdge.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom
);
var anyEdgesAreSolvableWithDMoves =
bottomEdges.Count(bE =>
bE.Position.HasFlag(CubeFlag.BottomLayer) &&
bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom
) > 0;
if (anyEdgesAreSolvableWithDMoves)
{
while (!bottomEdgesInBottomLayerCorrectlyOriented.Any())
{
// turn the bottom layer until at least one is
SolverMove(CubeFlag.BottomLayer, true);
bottomEdgesInBottomLayerCorrectlyOriented =
bottomEdges.Where(bE =>
bE.Position.Flags == GetTargetFlags(bE) &&
bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom
);
}
}
// Step 3: Solve incorrect edges of the bottom layer
while (bottomEdgesInBottomLayerCorrectlyOriented.Count() < 4)
{
IEnumerable <Cube> unsolvedBottomEdges = bottomEdges.Except(bottomEdgesInBottomLayerCorrectlyOriented);
Cube e =
unsolvedBottomEdges.FirstOrDefault(c => c.Position.HasFlag(CubeFlag.TopLayer))
?? unsolvedBottomEdges.First();
Color secondColor =
e.Colors.First(co =>
co != Rubik.BottomColor &&
co != Color.Black
);
if (e.Position.Flags != GetTargetFlags(e))
{
// Rotate to top layer
CubeFlag layer =
CubeFlagService.FromFacePosition(
e.Faces.First(f =>
(f.Color == Rubik.BottomColor || f.Color == secondColor) &&
f.Position != FacePosition.Top && f.Position != FacePosition.Bottom
).Position
);
CubeFlag targetLayer =
CubeFlagService.FromFacePosition(
StandardCube.Cubes.First(cu =>
CollectionMethods.ScrambledEquals(cu.Colors, e.Colors)
)
.Faces
.First(f => f.Color == secondColor)
.Position
);
if (e.Position.HasFlag(CubeFlag.MiddleLayer))
{
if (layer == targetLayer)
{
while (!e.Position.HasFlag(CubeFlag.BottomLayer))
{
SolverMove(layer, true);
}
}
else
{
SolverMove(layer, true);
if (e.Position.HasFlag(CubeFlag.TopLayer))
{
SolverMove(CubeFlag.TopLayer, true);
SolverMove(layer, false);
}
else
{
for (int i = 0; i < 2; i++)
{
SolverMove(layer, true);
}
SolverMove(CubeFlag.TopLayer, true);
SolverMove(layer, true);
}
}
}
if (e.Position.HasFlag(CubeFlag.BottomLayer))
{
for (int i = 0; i < 2; i++)
{
SolverMove(layer, true);
}
}
// Rotate over target position
while (!e.Position.HasFlag(targetLayer))
{
SolverMove(CubeFlag.TopLayer, true);
}
//Rotate to target position
for (int i = 0; i < 2; i++)
{
SolverMove(targetLayer, true);
}
}
// Flip the incorrect orientated edges with the algorithm: F' D R' D'
if (Solvability.GetOrientation(Rubik, e) != 0)
{
CubeFlag frontSlice = CubeFlagService.FromFacePosition(e.Faces.First(f => f.Color == Rubik.BottomColor).Position);
SolverMove(frontSlice, false);
SolverMove(CubeFlag.BottomLayer, true);
CubeFlag rightSlice = CubeFlagService.FromFacePosition(e.Faces.First(f => f.Color == secondColor).Position);
SolverMove(rightSlice, false);
SolverMove(CubeFlag.BottomLayer, false);
}
bottomEdgesInBottomLayerCorrectlyOriented =
bottomEdges.Where(bE =>
bE.Position.Flags == GetTargetFlags(bE) &&
bE.Faces.First(f => f.Color == Rubik.BottomColor).Position == FacePosition.Bottom
);
}
}