Exemple #1
0
 private CubeModel(float radius)
 {
     this.position = identityPosition;
     this.position.faceX.position0  *= radius;
     this.position.faceX.position1  *= radius;
     this.position.faceX.position2  *= radius;
     this.position.faceX.position3  *= radius;
     this.position.faceNX.position0 *= radius;
     this.position.faceNX.position1 *= radius;
     this.position.faceNX.position2 *= radius;
     this.position.faceNX.position3 *= radius;
     this.position.faceY.position0  *= radius;
     this.position.faceY.position1  *= radius;
     this.position.faceY.position2  *= radius;
     this.position.faceY.position3  *= radius;
     this.position.faceNY.position0 *= radius;
     this.position.faceNY.position1 *= radius;
     this.position.faceNY.position2 *= radius;
     this.position.faceNY.position3 *= radius;
     this.position.faceZ.position0  *= radius;
     this.position.faceZ.position1  *= radius;
     this.position.faceZ.position2  *= radius;
     this.position.faceZ.position3  *= radius;
     this.position.faceNZ.position0 *= radius;
     this.position.faceNZ.position1 *= radius;
     this.position.faceNZ.position2 *= radius;
     this.position.faceNZ.position3 *= radius;
     this.color  = identityColor;
     this.normal = identityNormal;
     this.index  = identityIndex;
 }
        /// <summary>
        /// Transforms the pattern item
        /// </summary>
        /// <param name="type">Transformation axis</param>
        public void Transform(CubeFlag rotationLayer)
        {
            if (CurrentPosition.HasFlag(rotationLayer))
            {
                CubeFlag oldFlags = this.CurrentPosition.Flags;
                CurrentPosition.NextFlag(rotationLayer, true);


                Orientation newOrientation = this.CurrentOrientation;
                if (CubePosition.IsCorner(CurrentPosition.Flags) && !CubeFlagService.IsYFlag(rotationLayer))
                {
                    if (new CubePosition(oldFlags).Y == new CubePosition(CurrentPosition.Flags).Y)
                    {
                        newOrientation = (Orientation)(((int)newOrientation + 2) % 3);
                    }
                    else
                    {
                        newOrientation = (Orientation)(((int)newOrientation + 1) % 3);
                    }
                }
                else if (CubePosition.IsEdge(CurrentPosition.Flags) && CubeFlagService.IsZFlag(rotationLayer))
                {
                    newOrientation = (Orientation)((int)newOrientation ^ 0x1);
                }

                this.CurrentOrientation = newOrientation;
            }
            if (TargetPosition.HasFlag(rotationLayer))
            {
                TargetPosition = CubeFlagService.NextFlags(TargetPosition, rotationLayer, true);
            }
        }
    private void Start()
    {
        Cursor.lockState    = CursorLockMode.Locked;
        originAndGroundYPos = originAndGround.position.y;
        DIR[0]    = new CubePosition(groundSizeX, 0, 0);
        DIR[1]    = new CubePosition(-groundSizeX, 0, 0);
        DIR[2]    = new CubePosition(0, 0, groundSizeZ);
        DIR[3]    = new CubePosition(0, 0, -groundSizeZ);
        DIR[4]    = new CubePosition(0, groundSizeY, 0);
        DIR[5]    = new CubePosition(0, -groundSizeY, 0);
        worldData = new GroundBlockData[worldSizeX, worldSizeY, worldSizeZ];
        for (int i = 0; i < worldSizeX; i++)
        {
            for (int j = 0; j < worldSizeY; j++)
            {
                for (int k = 0; k < worldSizeZ; k++)
                {
                    worldData[i, j, k] = new GroundBlockData(false, true);
                    //Debug.Log(i + " " + j + " " + k + "\n"); // will cause non responsive editor!!
                }
            }
        }

        int[]   idxOriginGnd = GetIdx(originAndGround.position);
        Vector3 pos;

        for (int i = 0; i < worldSizeX; i++)
        {
            for (int j = 0; j < worldSizeZ; j++)
            {
                pos = GetPos(new int[] { i, idxOriginGnd[1], j });
                worldData[i, idxOriginGnd[1], j].SetPosForInitCubesOnly(pos);

                worldData[i, idxOriginGnd[1], j].rend          = Instantiate(_prefabGroundCube, pos, Quaternion.identity, transform).GetComponent <Renderer>();
                worldData[i, idxOriginGnd[1], j].rend.enabled  = false;
                worldData[i, idxOriginGnd[1], j].isSpawned     = true;
                worldData[i, idxOriginGnd[1], j].isMinedBefore = false;
                //Debug.Log(i + " " + j + " " + k + "\n");
            }
        }

        //for (int i = 0; i < initGroundBlocksHolder.Length; i++)
        //{
        //    for (int j = 0; j < initGroundBlocksHolder[i].childCount; j++)
        //    {
        //        int[] idx = GetIdx(initGroundBlocksHolder[i].GetChild(j).position);
        //        worldData[idx[0], idx[1], idx[2]].SetPosForInitCubesOnly(initGroundBlocksHolder[i].GetChild(j).position);
        //    }
        //}
    }
Exemple #4
0
    public static void savePostion(cube Cube)
    {
        // Create BinaryFormater
        BinaryFormatter bf = new BinaryFormatter();
        // Create file to save to
        FileStream stream = new FileStream(Application.persistentDataPath + "/position.cav", FileMode.Create);

        // Set data to be stored
        CubePosition data = new CubePosition(Cube);

        // Serialize data
        bf.Serialize(stream, data);

        stream.Close();
    }
Exemple #5
0
    public static float[] loadPosition()
    {
        if (File.Exists(Application.persistentDataPath + "/position.cav"))
        {
            // Create BinaryFormater
            BinaryFormatter bf = new BinaryFormatter();
            // Open file to save to
            FileStream stream = new FileStream(Application.persistentDataPath + "/position.cav", FileMode.Open);

            CubePosition data = bf.Deserialize(stream) as CubePosition;

            stream.Close();
            return(data.stats);
        }
        else
        {
            return(null);
        }
    }
 /// <summary>
 /// Initializes a new instance of the PatternItem class
 /// </summary>
 /// <param name="currPos">Current position</param>
 /// <param name="currOrientation">
 /// Current orientation
 /// Corner: Correct = 0, Clockwise = 1, Counter-Clockwise = 2
 /// Edge: Correct = 0, Flipped = 1
 /// Center always 0
 /// </param>
 /// <param name="targetPos">Target position</param>
 public PatternItem(CubePosition currPos, Orientation currOrientation, CubeFlag targetPos)
 {
     this.CurrentPosition    = currPos;
     this.CurrentOrientation = currOrientation;
     this.TargetPosition     = targetPos;
 }
 /// <summary>
 /// Constructor with faces and position
 /// </summary>
 /// <param name="faces">Defines the faces where the cube belongs to</param>
 /// <param name="position">Defines the position of the cube</param>
 public Cube(IEnumerable<Face> faces, CubePosition position)
 {
     this.Faces = faces;
     this.Position = position;
 }
        public PositionSpec Render2D(Graphics g, IEnumerable<Face3D> frame, Point mousePos)
        {
            g.SmoothingMode = SmoothingMode.AntiAlias;
              PositionSpec pos = PositionSpec.Default;

              int square = 0, borderX = 5, borderY = 5;
              if (((double)(this.Screen.Width - 10) / (double)(this.Screen.Height - 10)) > (4.0 / 3.0))
              {
            square = (int)(this.Screen.Height / 9.0);
            borderX = (this.Screen.Width - 12 * square) / 2;
              }
              else
              {
            square = (int)(this.Screen.Width / 12.0);
            borderY = (this.Screen.Height - 9 * square) / 2;
              }

              List<Face3D> faces = new List<Face3D>();
              foreach (Cube c in this.Rubik.Cubes)
            faces.AddRange(c.Faces.Where(f => c.Position.Flags.HasFlag(CubeFlagService.FromFacePosition(f.Position))).Select(f => new Face3D(null, f.Color, f.Position, c.Position.Flags)));
              frame = faces;

              foreach (Face3D face in frame)
              {
            #region CalculatePoints

            int x = 0, y = 0;
            int xOffs = borderX, yOffs = borderY;

            if (face.Position.HasFlag(FacePosition.Front))
            {
              xOffs += 3 * square; yOffs += 3 * square;
              CubePosition cubePos = new CubePosition(face.MasterPosition);
              x = xOffs + (CubeFlagService.ToInt(cubePos.X) + 1) * square;
              y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
            }

            if (face.Position.HasFlag(FacePosition.Top))
            {
              xOffs += 3 * square;
              CubePosition cubePos = new CubePosition(face.MasterPosition);
              x = xOffs + (CubeFlagService.ToInt(cubePos.X) + 1) * square;
              y = yOffs + (CubeFlagService.ToInt(cubePos.Z) + 1) * square;
            }

            if (face.Position.HasFlag(FacePosition.Bottom))
            {
              xOffs += 3 * square; yOffs += 6 * square;
              CubePosition cubePos = new CubePosition(face.MasterPosition);
              x = xOffs + (CubeFlagService.ToInt(cubePos.X) + 1) * square;
              y = yOffs + (CubeFlagService.ToInt(cubePos.Z) * (-1) + 1) * square;
            }

            if (face.Position.HasFlag(FacePosition.Left))
            {
              yOffs += 3 * square;
              CubePosition cubePos = new CubePosition(face.MasterPosition);
              x = xOffs + (CubeFlagService.ToInt(cubePos.Z) + 1) * square;
              y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
            }

            if (face.Position.HasFlag(FacePosition.Right))
            {
              xOffs += 6 * square; yOffs += 3 * square;
              CubePosition cubePos = new CubePosition(face.MasterPosition);
              x = xOffs + (CubeFlagService.ToInt(cubePos.Z) * (-1) + 1) * square;
              y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
            }

            if (face.Position.HasFlag(FacePosition.Back))
            {
              xOffs += 9 * square; yOffs += 3 * square;
              CubePosition cubePos = new CubePosition(face.MasterPosition);
              x = xOffs + (CubeFlagService.ToInt(cubePos.X) * (-1) + 1) * square;
              y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
            }
            #endregion

            Point[] parr = new Point[] { new Point(x, y), new Point(x, y + square), new Point(x + square, y + square), new Point(x + square, y)  };

            Brush b = new SolidBrush(face.Color);
            double factor = ((Math.Sin((double)Environment.TickCount / (double)200) + 1) / 4) + 0.75;
            PositionSpec facePos = new PositionSpec() { FacePosition = face.Position, CubePosition = face.MasterPosition };

            if (this.MouseHandling)
            {
              if (_selections[facePos].HasFlag(Selection.Second))
            b = new HatchBrush(HatchStyle.Percent75, Color.Black, face.Color);
              else if (_selections[facePos].HasFlag(Selection.NotPossible))
            b = new SolidBrush(Color.FromArgb(face.Color.A, (int)(face.Color.R * 0.3), (int)(face.Color.G * 0.3), (int)(face.Color.B * 0.3)));
              else if (_selections[facePos].HasFlag(Selection.First))
            b = new HatchBrush(HatchStyle.Percent30, Color.Black, face.Color);
              else if (_selections[facePos].HasFlag(Selection.Possible))
            b = new SolidBrush(Color.FromArgb(face.Color.A, (int)(Math.Min(face.Color.R * factor, 255)), (int)(Math.Min(face.Color.G * factor, 255)), (int)(Math.Min(face.Color.B * factor, 255))));
              else b = new SolidBrush(face.Color);
            }
            else
              b = new SolidBrush(face.Color);

            g.FillPolygon(b, parr);
            g.DrawPolygon(new Pen(Color.Black, 1), parr);

            GraphicsPath gp = new GraphicsPath();
            gp.AddPolygon(parr);
            if (gp.IsVisible(mousePos))
              pos = facePos;
              }

              g.DrawRectangle(Pens.Black, 0, this.Height - 25, this.Width - 1, 24);
              //g.DrawLine(Pens.Black, 0, this.Height - 25, this.Width, this.Height - 25);
              g.DrawString(string.Format("[{0}] | {1}", _currentSelection.CubePosition, _currentSelection.FacePosition), this.Font, Brushes.Black, 5, this.Height - 20);

              g.DrawRectangle(Pens.Black, 0, this.Height - 50, this.Width - 1, 25);
              g.DrawString(this.State, this.Font, Brushes.Black, 5, this.Height - 45);

              g.DrawRectangle(Pens.Black, 0, 0, this.Width - 1, this.Height - 50);

              return pos;
        }
 /// <summary>
 /// Initializes a new instance of the PatternItem class
 /// </summary>
 /// <param name="currPos">Current position</param>
 /// <param name="currOrientation">
 /// Current orientation
 /// Corner: Correct = 0, Clockwise = 1, Counter-Clockwise = 2
 /// Edge: Correct = 0, Flipped = 1
 /// Center always 0
 /// </param>
 /// <param name="targetPos">Target position</param>
 public PatternItem(CubePosition currPos, Orientation currOrientation, CubeFlag targetPos)
 {
     this.CurrentPosition = currPos;
     this.CurrentOrientation = currOrientation;
     this.TargetPosition = targetPos;
 }
        /// <summary>
        /// Transforms the pattern item
        /// </summary>
        /// <param name="type">Transformation axis</param>
        public void Transform(CubeFlag rotationLayer)
        {
            if (this.CurrentPosition.HasFlag(rotationLayer))
            {
                var oldFlags = this.CurrentPosition.Flags;
                this.CurrentPosition.NextFlag(rotationLayer, true);

                var newOrientation = this.CurrentOrientation;
                if (CubePosition.IsCorner(this.CurrentPosition.Flags) && !CubeFlagService.IsYFlag(rotationLayer))
                {
                    newOrientation = new CubePosition(oldFlags).Y == new CubePosition(this.CurrentPosition.Flags).Y ? (Orientation)(((int)newOrientation + 0x2) % 3) : (Orientation)(((int)newOrientation + 1) % 3);
                }
                else if (CubePosition.IsEdge(this.CurrentPosition.Flags) && CubeFlagService.IsZFlag(rotationLayer))
                {
                    newOrientation = (Orientation)((int)newOrientation ^ 0x1);
                }

                this.CurrentOrientation = newOrientation;
            }
            if (this.TargetPosition.HasFlag(rotationLayer)) this.TargetPosition = CubeFlagService.NextFlags(this.TargetPosition, rotationLayer);
        }
 /// <summary>
 /// Method that invokes CubePosition event
 /// </summary>
 /// <param name="cubePos"></param>
 protected virtual void OnCubePosition(LeftMiddleRight pushTo)
 => CubePosition?.Invoke(pushTo);
        private void CompleteF2L()
        {
            List <Tuple <Cube, Cube> > unsolvedPairs = GetPairs(this.Rubik).ToList();

            while (unsolvedPairs.Count > 0) // 4 pairs
            {
                Tuple <Cube, Cube> currentPair = unsolvedPairs.First();

                Cube edge   = currentPair.Item1;
                Cube corner = currentPair.Item2;

                CubePosition target = new CubePosition(Rubik.GetTargetFlags(corner));

                if (!corner.Position.HasFlag(CubeFlag.TopLayer) && Rubik.GetTargetFlags(corner) != corner.Position.Flags)
                {
                    CubeFlag rotationLayer = CubeFlagService.FirstNotInvalidFlag(corner.Position.Flags, CubeFlag.BottomLayer);
                    bool     direction     = new TestScenario(Rubik, new LayerMove(rotationLayer)).TestCubePosition(corner, CubeFlag.TopLayer);
                    SolverMove(rotationLayer, direction);
                    SolverMove(CubeFlag.TopLayer, true);
                    SolverMove(rotationLayer, !direction);
                }
                // move edge to top position if necessary
                if (!edge.Position.HasFlag(CubeFlag.TopLayer) && Rubik.GetTargetFlags(edge) != edge.Position.Flags)
                {
                    CubeFlag rotationLayer = CubeFlagService.FirstNotInvalidFlag(edge.Position.Flags, CubeFlag.MiddleLayer);
                    bool     direction     = new TestScenario(Rubik, new LayerMove(rotationLayer)).TestCubePosition(edge, CubeFlag.TopLayer);
                    SolverMove(rotationLayer, direction);
                    while ((corner.Position.HasFlag(rotationLayer) && !corner.Position.HasFlag(CubeFlag.BottomLayer)) || edge.Position.HasFlag(rotationLayer))
                    {
                        SolverMove(CubeFlag.TopLayer, true);
                    }
                    SolverMove(rotationLayer, !direction);
                }

                // detect right and front slice
                CubeFlag rightSlice = CubeFlagService.ToInt(target.X) == CubeFlagService.ToInt(target.Z) ? target.Z : target.X;
                CubeFlag frontSlice = CubeFlagService.FirstNotInvalidFlag(target.Flags, CubeFlag.YFlags | rightSlice);

                while (!corner.Position.HasFlag(target.Flags & ~CubeFlag.BottomLayer))
                {
                    SolverMove(CubeFlag.TopLayer, true);
                }

                PatternFilter filter = new PatternFilter(new Func <Pattern, Pattern, bool>(delegate(Pattern p1, Pattern p2)
                {
                    PatternItem item = new PatternItem(corner.Position, Solvability.GetOrientation(this.Rubik, corner), target.Flags);
                    return(p2.Items.Any(i => i.Equals(item)));
                }), true);

                Algorithm algo = null;
                for (int i = 0; i < 4; i++)
                {
                    F2LPattern pattern = new F2LPattern(Rubik.GetTargetFlags(edge), Rubik.GetTargetFlags(corner), rightSlice, frontSlice);
                    algo = pattern.FindBestMatch(Pattern.FromRubik(Rubik), CubeFlag.None, filter);
                    if (algo != null)
                    {
                        SolverAlgorithm(algo); break;
                    }
                    SolverMove(CubeFlag.TopLayer, true);
                }

                int count = unsolvedPairs.Count;
                unsolvedPairs = GetPairs(this.Rubik).ToList();
                if (unsolvedPairs.Count == count)
                {
                    this.BroadcastOnSolutionError("Complete first two layers", "Wrong algorithm");
                    return;
                }
            }
        }
Exemple #13
0
        public PositionSpec Render2D(Graphics g, IEnumerable <Face3D> frame, Point mousePos)
        {
            g.SmoothingMode = SmoothingMode.AntiAlias;
            PositionSpec pos = PositionSpec.Default;

            int square = 0, borderX = 5, borderY = 5;

            if (((double)(this.Screen.Width - 10) / (double)(this.Screen.Height - 10)) > (4.0 / 3.0))
            {
                square  = (int)(this.Screen.Height / 9.0);
                borderX = (this.Screen.Width - 12 * square) / 2;
            }
            else
            {
                square  = (int)(this.Screen.Width / 12.0);
                borderY = (this.Screen.Height - 9 * square) / 2;
            }

            List <Face3D> faces = new List <Face3D>();

            foreach (Cube c in this.Rubik.Cubes)
            {
                faces.AddRange(c.Faces.Where(f => c.Position.Flags.HasFlag(CubeFlagService.FromFacePosition(f.Position))).Select(f => new Face3D(null, f.Color, f.Position, c.Position.Flags)));
            }
            frame = faces;

            foreach (Face3D face in frame)
            {
                #region CalculatePoints

                int x = 0, y = 0;
                int xOffs = borderX, yOffs = borderY;

                if (face.Position.HasFlag(FacePosition.Front))
                {
                    xOffs += 3 * square; yOffs += 3 * square;
                    CubePosition cubePos = new CubePosition(face.MasterPosition);
                    x = xOffs + (CubeFlagService.ToInt(cubePos.X) + 1) * square;
                    y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
                }

                if (face.Position.HasFlag(FacePosition.Top))
                {
                    xOffs += 3 * square;
                    CubePosition cubePos = new CubePosition(face.MasterPosition);
                    x = xOffs + (CubeFlagService.ToInt(cubePos.X) + 1) * square;
                    y = yOffs + (CubeFlagService.ToInt(cubePos.Z) + 1) * square;
                }

                if (face.Position.HasFlag(FacePosition.Bottom))
                {
                    xOffs += 3 * square; yOffs += 6 * square;
                    CubePosition cubePos = new CubePosition(face.MasterPosition);
                    x = xOffs + (CubeFlagService.ToInt(cubePos.X) + 1) * square;
                    y = yOffs + (CubeFlagService.ToInt(cubePos.Z) * (-1) + 1) * square;
                }

                if (face.Position.HasFlag(FacePosition.Left))
                {
                    yOffs += 3 * square;
                    CubePosition cubePos = new CubePosition(face.MasterPosition);
                    x = xOffs + (CubeFlagService.ToInt(cubePos.Z) + 1) * square;
                    y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
                }

                if (face.Position.HasFlag(FacePosition.Right))
                {
                    xOffs += 6 * square; yOffs += 3 * square;
                    CubePosition cubePos = new CubePosition(face.MasterPosition);
                    x = xOffs + (CubeFlagService.ToInt(cubePos.Z) * (-1) + 1) * square;
                    y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
                }

                if (face.Position.HasFlag(FacePosition.Back))
                {
                    xOffs += 9 * square; yOffs += 3 * square;
                    CubePosition cubePos = new CubePosition(face.MasterPosition);
                    x = xOffs + (CubeFlagService.ToInt(cubePos.X) * (-1) + 1) * square;
                    y = yOffs + (CubeFlagService.ToInt(cubePos.Y) * (-1) + 1) * square;
                }
                #endregion

                Point[] parr = new Point[] { new Point(x, y), new Point(x, y + square), new Point(x + square, y + square), new Point(x + square, y) };

                Brush        b       = new SolidBrush(face.Color);
                double       factor  = ((Math.Sin((double)Environment.TickCount / (double)200) + 1) / 4) + 0.75;
                PositionSpec facePos = new PositionSpec()
                {
                    FacePosition = face.Position, CubePosition = face.MasterPosition
                };

                if (this.MouseHandling)
                {
                    if (_selections[facePos].HasFlag(Selection.Second))
                    {
                        b = new HatchBrush(HatchStyle.Percent75, Color.Black, face.Color);
                    }
                    else if (_selections[facePos].HasFlag(Selection.NotPossible))
                    {
                        b = new SolidBrush(Color.FromArgb(face.Color.A, (int)(face.Color.R * 0.3), (int)(face.Color.G * 0.3), (int)(face.Color.B * 0.3)));
                    }
                    else if (_selections[facePos].HasFlag(Selection.First))
                    {
                        b = new HatchBrush(HatchStyle.Percent30, Color.Black, face.Color);
                    }
                    else if (_selections[facePos].HasFlag(Selection.Possible))
                    {
                        b = new SolidBrush(Color.FromArgb(face.Color.A, (int)(Math.Min(face.Color.R * factor, 255)), (int)(Math.Min(face.Color.G * factor, 255)), (int)(Math.Min(face.Color.B * factor, 255))));
                    }
                    else
                    {
                        b = new SolidBrush(face.Color);
                    }
                }
                else
                {
                    b = new SolidBrush(face.Color);
                }

                g.FillPolygon(b, parr);
                g.DrawPolygon(new Pen(Color.Black, 1), parr);


                GraphicsPath gp = new GraphicsPath();
                gp.AddPolygon(parr);
                if (gp.IsVisible(mousePos))
                {
                    pos = facePos;
                }
            }

            g.DrawRectangle(Pens.Black, 0, this.Height - 25, this.Width - 1, 24);
            //g.DrawLine(Pens.Black, 0, this.Height - 25, this.Width, this.Height - 25);
            g.DrawString(string.Format("[{0}] | {1}", _currentSelection.CubePosition, _currentSelection.FacePosition), this.Font, Brushes.Black, 5, this.Height - 20);

            g.DrawRectangle(Pens.Black, 0, this.Height - 50, this.Width - 1, 25);
            g.DrawString(this.State, this.Font, Brushes.Black, 5, this.Height - 45);

            g.DrawRectangle(Pens.Black, 0, 0, this.Width - 1, this.Height - 50);

            return(pos);
        }
        /// <summary>
        /// Detection and execution of mouse-controlled layer rotations
        /// </summary>
        protected override void OnMouseClick(MouseEventArgs e)
        {
            if (this.MouseHandling)
            {
                if (e.Button == System.Windows.Forms.MouseButtons.Left)
                {
                    if (_oldSelection.IsDefault)
                    {
                        if (_currentSelection.IsDefault)
                        {
                            _selections.Reset();
                            _oldSelection     = PositionSpec.Default;
                            _currentSelection = PositionSpec.Default;
                        }
                        else
                        {
                            if (!CubePosition.IsCorner(_currentSelection.CubePosition))
                            {
                                _oldSelection = _currentSelection;
                                this.Rubik.Cubes.ForEach(c => c.Faces.Where(f => f.Color != Color.Black).ToList().ForEach(f =>
                                {
                                    PositionSpec pos = new PositionSpec()
                                    {
                                        CubePosition = c.Position.Flags, FacePosition = f.Position
                                    };

                                    if (_currentSelection.CubePosition != c.Position.Flags && !CubePosition.IsCenter(c.Position.Flags) && _currentSelection.FacePosition == f.Position)
                                    {
                                        CubeFlag assocLayer  = CubeFlagService.FromFacePosition(_currentSelection.FacePosition);
                                        CubeFlag commonLayer = CubeFlagService.GetFirstNotInvalidCommonFlag(_currentSelection.CubePosition, c.Position.Flags, assocLayer);

                                        if (commonLayer != CubeFlag.None && c.Position.HasFlag(commonLayer))
                                        {
                                            _selections[pos] |= Selection.Possible;
                                        }
                                        else
                                        {
                                            _selections[pos] |= Selection.NotPossible;
                                        }
                                    }
                                    else
                                    {
                                        _selections[pos] |= Selection.NotPossible;
                                    }
                                }));
                                this.State = string.Format("First selection [{0}] | {1}", _currentSelection.CubePosition, _currentSelection.FacePosition);
                            }
                            else
                            {
                                _selections.Reset();
                                this.State = "Error: Invalid first selection, must not be a corner";
                            }
                        }
                    }
                    else
                    {
                        if (_currentSelection.IsDefault)
                        {
                            this.State = "Ready";
                        }
                        else
                        {
                            if (_currentSelection.CubePosition != _oldSelection.CubePosition)
                            {
                                if (!CubePosition.IsCenter(_currentSelection.CubePosition))
                                {
                                    if (_oldSelection.FacePosition == _currentSelection.FacePosition)
                                    {
                                        CubeFlag assocLayer  = CubeFlagService.FromFacePosition(_oldSelection.FacePosition);
                                        CubeFlag commonLayer = CubeFlagService.GetFirstNotInvalidCommonFlag(_oldSelection.CubePosition, _currentSelection.CubePosition, assocLayer);
                                        bool     direction   = true;

                                        if (commonLayer == CubeFlag.TopLayer || commonLayer == CubeFlag.MiddleLayer || commonLayer == CubeFlag.BottomLayer)
                                        {
                                            if (((_oldSelection.FacePosition == FacePosition.Back) && _currentSelection.CubePosition.HasFlag(CubeFlag.RightSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Left) && _currentSelection.CubePosition.HasFlag(CubeFlag.BackSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Front) && _currentSelection.CubePosition.HasFlag(CubeFlag.LeftSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Right) && _currentSelection.CubePosition.HasFlag(CubeFlag.FrontSlice)))
                                            {
                                                direction = false;
                                            }
                                            if (commonLayer == CubeFlag.TopLayer || commonLayer == CubeFlag.MiddleLayer)
                                            {
                                                direction = !direction;
                                            }
                                        }

                                        if (commonLayer == CubeFlag.LeftSlice || commonLayer == CubeFlag.MiddleSliceSides || commonLayer == CubeFlag.RightSlice)
                                        {
                                            if (((_oldSelection.FacePosition == FacePosition.Bottom) && _currentSelection.CubePosition.HasFlag(CubeFlag.BackSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Back) && _currentSelection.CubePosition.HasFlag(CubeFlag.TopLayer)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Top) && _currentSelection.CubePosition.HasFlag(CubeFlag.FrontSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Front) && _currentSelection.CubePosition.HasFlag(CubeFlag.BottomLayer)))
                                            {
                                                direction = false;
                                            }
                                            if (commonLayer == CubeFlag.LeftSlice)
                                            {
                                                direction = !direction;
                                            }
                                        }

                                        if (commonLayer == CubeFlag.BackSlice || commonLayer == CubeFlag.MiddleSlice || commonLayer == CubeFlag.FrontSlice)
                                        {
                                            if (((_oldSelection.FacePosition == FacePosition.Top) && _currentSelection.CubePosition.HasFlag(CubeFlag.RightSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Right) && _currentSelection.CubePosition.HasFlag(CubeFlag.BottomLayer)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Bottom) && _currentSelection.CubePosition.HasFlag(CubeFlag.LeftSlice)) ||
                                                ((_oldSelection.FacePosition == FacePosition.Left) && _currentSelection.CubePosition.HasFlag(CubeFlag.TopLayer)))
                                            {
                                                direction = false;
                                            }
                                            if (commonLayer == CubeFlag.FrontSlice || commonLayer == CubeFlag.MiddleSlice)
                                            {
                                                direction = !direction;
                                            }
                                        }

                                        if (commonLayer != CubeFlag.None)
                                        {
                                            RotateLayerAnimated(commonLayer, direction);
                                        }
                                        else
                                        {
                                            this.State = "Error: Invalid second selection, does not specify distinct layer";
                                        }
                                    }
                                    else
                                    {
                                        this.State = "Error: Invalid second selection, must match orientation of first selection";
                                    }
                                }
                                else
                                {
                                    this.State = "Error: Invalid second selection, must not be a center";
                                }
                            }
                            else
                            {
                                this.State = "Error: Invalid second selection, must not be first selection";
                            }
                        }
                        _selections.Reset();
                        _oldSelection     = PositionSpec.Default;
                        _currentSelection = PositionSpec.Default;
                    }
                }
            }

            base.OnMouseClick(e);
        }
Exemple #15
0
 /// <summary>
 /// Constructor with faces and position
 /// </summary>
 /// <param name="faces">Defines the faces where the cube belongs to</param>
 /// <param name="position">Defines the position of the cube</param>
 public Cube(IEnumerable <Face> faces, CubePosition position)
 {
     this.Faces    = faces;
     this.Position = position;
 }
Exemple #16
0
        // **** METHODS ****

        public static Rubik FromPattern(Pattern pattern)
        {
            Rubik rubik = new Rubik();

            foreach (PatternItem item in pattern.Items)
            {
                if (CubePosition.IsCorner(item.CurrentPosition.Flags))
                {
                    bool xyzCorrect = !((item.CurrentPosition.Y == CubeFlag.TopLayer ^ (item.CurrentPosition.X == CubeFlag.RightSlice ^ item.CurrentPosition.Z == CubeFlag.FrontSlice))
                                        ^ (CubeFlagService.FirstYFlag(item.TargetPosition) == CubeFlag.TopLayer ^ (CubeFlagService.FirstXFlag(item.TargetPosition) == CubeFlag.RightSlice ^ CubeFlagService.FirstZFlag(item.TargetPosition) == CubeFlag.FrontSlice)));

                    if (item.CurrentOrientation == Orientation.Correct)
                    {
                        rubik.SetFaceColor(item.CurrentPosition.Flags, CubeFlagService.ToFacePosition(item.CurrentPosition.Y), rubik.GetSliceColor(CubeFlagService.FirstYFlag(item.TargetPosition)));

                        FacePosition x = xyzCorrect ? CubeFlagService.ToFacePosition(item.CurrentPosition.X) : CubeFlagService.ToFacePosition(item.CurrentPosition.Z);
                        FacePosition z = xyzCorrect ? CubeFlagService.ToFacePosition(item.CurrentPosition.Z) : CubeFlagService.ToFacePosition(item.CurrentPosition.X);

                        rubik.SetFaceColor(item.CurrentPosition.Flags, x, rubik.GetSliceColor(CubeFlagService.FirstXFlag(item.TargetPosition)));
                        rubik.SetFaceColor(item.CurrentPosition.Flags, z, rubik.GetSliceColor(CubeFlagService.FirstZFlag(item.TargetPosition)));
                    }
                    else
                    {
                        bool         corr = (item.CurrentPosition.X == CubeFlag.RightSlice ^ item.CurrentPosition.Z == CubeFlag.BackSlice) ^ item.CurrentPosition.Y == CubeFlag.BottomLayer;
                        FacePosition x    = (corr ^ item.CurrentOrientation == Orientation.Clockwise) ? CubeFlagService.ToFacePosition(item.CurrentPosition.X) : CubeFlagService.ToFacePosition(item.CurrentPosition.Y);
                        FacePosition y    = (corr ^ item.CurrentOrientation == Orientation.Clockwise) ? CubeFlagService.ToFacePosition(item.CurrentPosition.Z) : CubeFlagService.ToFacePosition(item.CurrentPosition.X);
                        FacePosition z    = (corr ^ item.CurrentOrientation == Orientation.Clockwise) ? CubeFlagService.ToFacePosition(item.CurrentPosition.Y) : CubeFlagService.ToFacePosition(item.CurrentPosition.Z);

                        rubik.SetFaceColor(item.CurrentPosition.Flags, x, rubik.GetSliceColor(CubeFlagService.FirstXFlag(item.TargetPosition)));
                        rubik.SetFaceColor(item.CurrentPosition.Flags, y, rubik.GetSliceColor(CubeFlagService.FirstYFlag(item.TargetPosition)));
                        rubik.SetFaceColor(item.CurrentPosition.Flags, z, rubik.GetSliceColor(CubeFlagService.FirstZFlag(item.TargetPosition)));
                    }
                }

                if (CubePosition.IsEdge(item.CurrentPosition.Flags))
                {
                    CubeFlag     flagOne = CubeFlagService.FirstNotInvalidFlag(item.CurrentPosition.Flags, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides);
                    FacePosition faceOne = CubeFlagService.ToFacePosition(flagOne);
                    FacePosition faceTwo = CubeFlagService.ToFacePosition(CubeFlagService.FirstNotInvalidFlag(item.CurrentPosition.Flags, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides | flagOne));

                    CubeFlag tFlagOne = CubeFlagService.FirstNotInvalidFlag(item.TargetPosition, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides);

                    rubik.SetFaceColor(item.CurrentPosition.Flags, faceOne, rubik.GetSliceColor(tFlagOne));
                    rubik.SetFaceColor(item.CurrentPosition.Flags, faceTwo, rubik.GetSliceColor(CubeFlagService.FirstNotInvalidFlag(item.TargetPosition, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides | tFlagOne)));

                    if (Solvability.GetOrientation(rubik, rubik.Cubes.First(c => c.Position.Flags == item.CurrentPosition.Flags)) != item.CurrentOrientation)
                    {
                        rubik.SetFaceColor(item.CurrentPosition.Flags, faceTwo, rubik.GetSliceColor(tFlagOne));
                        rubik.SetFaceColor(item.CurrentPosition.Flags, faceOne, rubik.GetSliceColor(CubeFlagService.FirstNotInvalidFlag(item.TargetPosition, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides | tFlagOne)));
                    }
                }

                if (CubePosition.IsCenter(item.CurrentPosition.Flags))
                {
                    CubeFlag flag  = CubeFlagService.FirstNotInvalidFlag(item.CurrentPosition.Flags, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides);
                    CubeFlag tFlag = CubeFlagService.FirstNotInvalidFlag(item.TargetPosition, CubeFlag.MiddleLayer | CubeFlag.MiddleSlice | CubeFlag.MiddleSliceSides);

                    rubik.SetFaceColor(item.CurrentPosition.Flags, CubeFlagService.ToFacePosition(flag), rubik.GetSliceColor(tFlag));
                }
            }
            return(rubik);
        }