예제 #1
0
 private int CountTopCornersAtTargetPosition(RubikManager manager)
 {
     return(manager.RubikCube.cubes.Count(c => Cube3D.isCorner(c.Position) && c.Position.HasFlag(Cube3D.RubikPosition.TopLayer) && c.Position == GetTargetPosition(c)));
 }
예제 #2
0
        private void CompleteLastLayer()
        {
            //Step 1: Get the color of the top layer to start with cross on the last layer
            Color topColor = Manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top);

            //Step 2: Get edges with the color of the top face
            IEnumerable <Cube3D> topCorners = Manager.RubikCube.cubes.Where(c => Cube3D.isCorner(c.Position)).Where(c => c.Position.HasFlag(Cube3D.RubikPosition.TopLayer));

            //Step 3: Bring corners to their target position
            while (topCorners.Where(c => c.Position == GetTargetPosition(c)).Count() < 4)
            {
                IEnumerable <Cube3D> correctCorners = topCorners.Where(c => c.Position == GetTargetPosition(c));
                Cube3D.RubikPosition rightSlice;
                if (correctCorners.Count() != 0)
                {
                    Cube3D firstCube = correctCorners.First();
                    Face3D rightFace = firstCube.Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top);
                    rightSlice = FacePosToCubePos(rightFace.Position);
                    Manager.SolutionMove(rightSlice, true);
                    if (RefreshCube(firstCube).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
                    {
                        Manager.SolutionMove(rightSlice, false);
                    }
                    else
                    {
                        Manager.SolutionMove(rightSlice, false);
                        rightSlice = FacePosToCubePos(firstCube.Faces.First(f => f.Color != rightFace.Color && f.Color != Color.Black && f.Position != Face3D.FacePosition.Top).Position);
                    }
                }
                else
                {
                    rightSlice = Cube3D.RubikPosition.RightSlice;
                }

                Cube3D.RubikPosition leftSlice = GetOppositeFace(rightSlice);
                Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                Manager.SolutionMove(rightSlice, true);
                Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, false);
                Manager.SolutionMove(leftSlice, false);
                Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                Manager.SolutionMove(rightSlice, false);
                Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, false);
                Manager.SolutionMove(leftSlice, true);
                topCorners     = topCorners.Select(tC => RefreshCube(tC));
                correctCorners = correctCorners.Select(cC => RefreshCube(cC));
            }

            //Step 4: Orientation of the corners on the top layer
            topCorners = topCorners.Select(tC => RefreshCube(tC));


            Face3D rightFac = RefreshCube(topCorners.First()).Faces.First(f => f.Color != Color.Black && f.Position != Face3D.FacePosition.Top);

            Cube3D.RubikPosition rightSlic = FacePosToCubePos(rightFac.Position);
            Manager.SolutionMove(rightSlic, true);
            if (RefreshCube(topCorners.First()).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
            {
                Manager.SolutionMove(rightSlic, false);
            }
            else
            {
                Manager.SolutionMove(rightSlic, false);
                rightSlic = FacePosToCubePos(topCorners.First().Faces.First(f => f.Color != rightFac.Color && f.Color != Color.Black && f.Position != Face3D.FacePosition.Top).Position);
            }

            foreach (Cube3D c in topCorners)
            {
                while (!RefreshCube(c).Position.HasFlag(rightSlic))
                {
                    Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                }
                Manager.SolutionMove(rightSlic, true);
                if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
                {
                    Manager.SolutionMove(rightSlic, false);
                }
                else
                {
                    Manager.SolutionMove(rightSlic, false);
                    Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                }

                //Algorithm: Ri Di R D
                while (RefreshCube(c).Faces.First(f => f.Position == Face3D.FacePosition.Top).Color != topColor)
                {
                    Manager.SolutionMove(rightSlic, false);
                    Manager.SolutionMove(Cube3D.RubikPosition.BottomLayer, false);
                    Manager.SolutionMove(rightSlic, true);
                    Manager.SolutionMove(Cube3D.RubikPosition.BottomLayer, true);
                }
            }

            topCorners = topCorners.Select(tC => RefreshCube(tC));
            while (topCorners.Count(tC => tC.Position == GetTargetPosition(tC)) != 4)
            {
                Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
            }
        }
예제 #3
0
        private int CountCornersWithCorrectOrientation(RubikManager manager)
        {
            Color topColor = manager.getFaceColor(Cube3D.RubikPosition.TopLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Top);

            return(manager.RubikCube.cubes.Count(c => Cube3D.isCorner(c.Position) && c.Faces.First(f => f.Position == Face3D.FacePosition.Top).Color == topColor));
        }
예제 #4
0
        private void CompleteFirstLayer()
        {
            //Step 1: Get the color of the bottom layer
            Color bottomColor = Manager.getFaceColor(Cube3D.RubikPosition.BottomLayer | Cube3D.RubikPosition.MiddleSlice_Sides | Cube3D.RubikPosition.MiddleSlice, Face3D.FacePosition.Bottom);

            //Step 2: Get the corners with target position on bottom layer
            IEnumerable <Cube3D> bottomCorners       = Manager.RubikCube.cubes.Where(c => Cube3D.isCorner(c.Position) && GetTargetPosition(c).HasFlag(Cube3D.RubikPosition.BottomLayer));
            IEnumerable <Cube3D> solvedBottomCorners = bottomCorners.Where(bC => bC.Position == GetTargetPosition(bC) && bC.Faces.First(f => f.Color == bottomColor).Position == Face3D.FacePosition.Bottom);

            //Step 3: Solve incorrect edges
            while (solvedBottomCorners.Count() < 4)
            {
                IEnumerable <Cube3D> unsolvedBottomCorners = bottomCorners.Except(solvedBottomCorners);
                Cube3D c = (unsolvedBottomCorners.FirstOrDefault(bC => bC.Position.HasFlag(Cube3D.RubikPosition.TopLayer)) != null)
                                        ? unsolvedBottomCorners.FirstOrDefault(bC => bC.Position.HasFlag(Cube3D.RubikPosition.TopLayer)) : unsolvedBottomCorners.First();

                if (c.Position != GetTargetPosition(c))
                {
                    //Rotate to top layer
                    if (c.Position.HasFlag(Cube3D.RubikPosition.BottomLayer))
                    {
                        Face3D leftFace = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Bottom && f.Color != Color.Black);
                        Cube3D.RubikPosition leftSlice = FacePosToCubePos(leftFace.Position);
                        Manager.SolutionMove(leftSlice, false);
                        if (RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.BottomLayer))
                        {
                            Manager.SolutionMove(leftSlice, true);
                            leftFace  = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Bottom && f.Color != leftFace.Color && f.Color != Color.Black);
                            leftSlice = FacePosToCubePos(leftFace.Position);
                            Manager.SolutionMove(leftSlice, false);
                        }
                        Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, false);
                        Manager.SolutionMove(leftSlice, true);
                        Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                    }

                    //Rotate over target position
                    Cube3D.RubikPosition targetPos = Cube3D.RubikPosition.None;
                    foreach (Cube3D.RubikPosition p in GetFlags(GetTargetPosition(c)))
                    {
                        if (p != Cube3D.RubikPosition.BottomLayer)
                        {
                            targetPos |= p;
                        }
                    }

                    while (!RefreshCube(c).Position.HasFlag(targetPos))
                    {
                        Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                    }
                }

                //Rotate to target position with the algorithm: Li Ui L U
                Face3D leftFac = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom && f.Color != Color.Black);

                Cube3D.RubikPosition leftSlic = FacePosToCubePos(leftFac.Position);

                Manager.SolutionMove(leftSlic, false);
                if (!RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.TopLayer))
                {
                    Manager.SolutionMove(leftSlic, true);
                    leftFac  = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom && f.Color != leftFac.Color && f.Color != Color.Black);
                    leftSlic = FacePosToCubePos(leftFac.Position);
                }
                else
                {
                    Manager.SolutionMove(leftSlic, true);
                }

                while (RefreshCube(c).Faces.First(f => f.Color == bottomColor).Position != Face3D.FacePosition.Bottom)
                {
                    if (RefreshCube(c).Faces.First(f => f.Color == bottomColor).Position == Face3D.FacePosition.Top)
                    {
                        Manager.SolutionMove(leftSlic, false);
                        Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                        Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                        Manager.SolutionMove(leftSlic, true);
                        Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                    }
                    else
                    {
                        Face3D frontFac = RefreshCube(c).Faces.First(f => f.Position != Face3D.FacePosition.Top && f.Position != Face3D.FacePosition.Bottom &&
                                                                     f.Color != Color.Black && f.Position != CubePosToFacePos(leftSlic));

                        if (RefreshCube(c).Faces.First(f => f.Color == bottomColor).Position == frontFac.Position && !RefreshCube(c).Position.HasFlag(Cube3D.RubikPosition.BottomLayer))
                        {
                            Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, false);
                            Manager.SolutionMove(leftSlic, false);
                            Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                            Manager.SolutionMove(leftSlic, true);
                        }
                        else
                        {
                            Manager.SolutionMove(leftSlic, false);
                            Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, false);
                            Manager.SolutionMove(leftSlic, true);
                            Manager.SolutionMove(Cube3D.RubikPosition.TopLayer, true);
                        }
                    }
                }
                solvedBottomCorners = bottomCorners.Where(bC => RefreshCube(bC).Position == GetTargetPosition(bC) && RefreshCube(bC).Faces.First(f => f.Color == bottomColor).Position == Face3D.FacePosition.Bottom);
            }
        }