Example #1
0
    private void SetCubeColor(Material[] cube, CubeColor color, FaceName face)
    {
        /* In order to set the color face we will take the face on which we wanna set the color*/
        switch (face)
        {
        case FaceName.Front:
            cube[5].color = GetMaterialForColor(color);
            break;

        case FaceName.Right:
            cube[4].color = GetMaterialForColor(color);
            break;

        case FaceName.Back:
            cube[3].color = GetMaterialForColor(color);
            break;

        case FaceName.Left:
            cube[2].color = GetMaterialForColor(color);
            break;

        case FaceName.Up:
            cube[1].color = GetMaterialForColor(color);
            break;

        case FaceName.Down:
            cube[0].color = GetMaterialForColor(color);
            break;
        }
    }
Example #2
0
        private void FlipB()
        {
            CubeColor temp = BU;

            BU = UB;
            UB = temp;
        }
Example #3
0
        private static void CornerDown_YellowSide_EdgeDown(FTLPair pair)
        {
            CubeColor color      = pair.Edge.GetColor(p => p.Face != DOWN);
            CubeFace  targetFace = Cube.GetFace(color);

            while (pair.Edge.GetPosition(p => p.Face != DOWN).Face != targetFace)
            {
                DoMove(DOWN);
            }

            CubeFace faceToRot = pair.Edge.GetPosition(p => p.Face != DOWN).Face;
            int      direction = SolvingUtility.GetDelta(pair.Edge.GetColor(p => p.Face != DOWN),
                                                         faceToRot, DOWN);

            // move edge in right position
            DoMove(faceToRot, direction);
            // pair the stones
            while (pair.Corner.GetColorPosition(color).Face != targetFace)
            {
                DoMove(DOWN);
            }

            DoMove(faceToRot, -direction);

            // handle as right paired
            RightPairedDownLayer(pair);
        }
Example #4
0
    protected virtual void SetCubeColor()
    {
        if (cubeColor == CubeColor.Neutral)
        {
            DOTween.Kill("CubeNeutralTween");

            int       whichPlayer      = (int)player;
            CubeColor cubeColorTest    = (CubeColor)whichPlayer + 1;
            Color     cubeCorrectColor = (GlobalVariables.Instance.playersColors[whichPlayer]);

            Color cubeColorTemp = cubeMaterial.GetColor("_Color");
            float cubeLerpTemp  = cubeMaterial.GetFloat("_Lerp");

            DOTween.To(() => cubeColorTemp, x => cubeColorTemp = x, cubeCorrectColor, toColorDuration).OnUpdate(() => cubeMaterial.SetColor("_Color", cubeColorTemp)).SetId("CubeColorTween");
            DOTween.To(() => cubeLerpTemp, x => cubeLerpTemp   = x, 1, toColorDuration).OnUpdate(() => cubeMaterial.SetFloat("_Lerp", cubeLerpTemp)).OnComplete(() => cubeColor = cubeColorTest);
        }

        else if (cubeColor != CubeColor.Neutral)
        {
            DOTween.Kill("CubeColorTween");

            Color cubeColorTemp = cubeMaterial.GetColor("_Color");
            float cubeLerpTemp  = cubeMaterial.GetFloat("_Lerp");

            DOTween.To(() => cubeColorTemp, x => cubeColorTemp = x, GlobalVariables.Instance.playersColors[4], toNeutralDuration).OnUpdate(() => cubeMaterial.SetColor("_Color", cubeColorTemp)).SetId("CubeNeutralTween");
            DOTween.To(() => cubeLerpTemp, x => cubeLerpTemp   = x, 0, toNeutralDuration).OnUpdate(() => cubeMaterial.SetFloat("_Lerp", cubeLerpTemp)).OnComplete(() => cubeColor = CubeColor.Neutral);
        }

        GetComponent <Renderer> ().material.color = cubeMaterial.GetColor("_Color");
    }
Example #5
0
    public void SetRandomColor()
    {
        int temp = Random.Range(0, 6);

        switch (temp)
        {
        case 0:
            cubeColor = CubeColor.Red;
            break;

        case 1:
            cubeColor = CubeColor.Green;
            break;

        case 2:
            cubeColor = CubeColor.Blue;
            break;

        case 3:
            cubeColor = CubeColor.Yellow;
            break;

        case 4:
            cubeColor = CubeColor.Cyan;
            break;

        case 5:
            cubeColor = CubeColor.Magenta;
            break;
        }
    }
Example #6
0
    void SpawnCubes(Vector3 positionToSpawn, Quaternion rotationToSpawn, CubeColor color)
    {
        GameObject clone;
        int        count = 0;

        switch (color)
        {
        case CubeColor.Red:
            GameObject newGroup = new GameObject("TestGroup");

            if (count < 4)
            {
                count++;
                gameObjectsArr.Add(Instantiate(cubeToSpawnRed, positionToSpawn, rotationToSpawn));
            }
            foreach (GameObject item in gameObjectsArr)
            {
                item.transform.parent = newGroup.transform;
            }

            break;

        case CubeColor.Green:
            clone = Instantiate(cubeToSpawnGreen, positionToSpawn, rotationToSpawn);
            break;

        case CubeColor.Black:
            clone = Instantiate(cubeToSpawnBlack, positionToSpawn, rotationToSpawn);
            break;
        }
    }
Example #7
0
        /// <summary>
        /// Rotate the top face clockwise
        /// </summary>
        public void U()
        {
            CubeColor temp1 = URF;

            URF = URB;
            URB = ULB;
            ULB = ULF;
            ULF = temp1;
            CubeColor temp2 = RUF;

            RUF = BUR;
            BUR = LUB;
            LUB = FUL;
            FUL = temp2;
            CubeColor temp3 = FUR;

            FUR = RUB;
            RUB = BUL;
            BUL = LUF;
            LUF = temp3;
            CubeColor temp4 = UR;

            UR = UB;
            UB = UL;
            UL = UF;
            UF = temp4;
            CubeColor temp5 = RU;

            RU = BU;
            BU = LU;
            LU = FU;
            FU = temp5;
        }
Example #8
0
        /// <summary>
        /// Gibt den Farbunterschied eines weißen Kantensteins zurück
        /// </summary>
        /// <param name="edge">Der Kantenstein, dessen Farbunterschied bestimmt werden soll</param>
        /// <returns></returns>
        protected int GetDelta(EdgeStone edge)
        {
            CubeColor edgeColor = edge.GetColors().First(c => c != WHITE);
            CubeFace  face      = edge.GetColorPosition(c => c != WHITE).Face;

            return(SolvingUtility.GetDelta(edgeColor, face, UP));
        }
Example #9
0
        public void RotateHorizontal()
        {
            CubeColor temp = xColor;

            xColor = yColor;
            yColor = temp;
        }
Example #10
0
    public void SetColor(CubeColor c)
    {
        color = c;

        if (color == CubeColor.Red)
        {
            GetComponent <Renderer>().sharedMaterial = redMaterial;
        }
        else if (color == CubeColor.Green)
        {
            GetComponent <Renderer>().sharedMaterial = greenMaterial;
        }
        else if (color == CubeColor.Blue)
        {
            GetComponent <Renderer>().sharedMaterial = blueMaterial;
        }
        else if (color == CubeColor.Gray)
        {
            GetComponent <Renderer>().sharedMaterial = grayMaterial;
        }
        else if (color == CubeColor.White)
        {
            GetComponent <Renderer>().sharedMaterial = whiteMaterial;
        }
    }
Example #11
0
 /// <summary>
 /// Given a cube color get the appropriate brush to fill the color
 /// </summary>
 /// <param name="c"></param>
 /// <returns></returns>
 public static Brush GetBrush(CubeColor c)
 {
     if (c == CubeColor.Blue)
     {
         return(Brushes.Blue);
     }
     if (c == CubeColor.Green)
     {
         return(Brushes.Green);
     }
     if (c == CubeColor.Orange)
     {
         return(Brushes.Orange);
     }
     if (c == CubeColor.Red)
     {
         return(Brushes.Red);
     }
     if (c == CubeColor.White)
     {
         return(Brushes.White);
     }
     if (c == CubeColor.Yellow)
     {
         return(Brushes.Yellow);
     }
     return(Brushes.DarkGray);
 }
Example #12
0
        private ConsoleColor ToConsoleColor(CubeColor color)
        {
            if (color == CubeColor.Red)
            {
                return(ConsoleColor.Red);
            }

            if (color == CubeColor.Blue)
            {
                return(ConsoleColor.Blue);
            }

            if (color == CubeColor.Green)
            {
                return(ConsoleColor.Green);
            }

            if (color == CubeColor.White)
            {
                return(ConsoleColor.White);
            }

            if (color == CubeColor.Orange)
            {
                return(ConsoleColor.DarkYellow);
            }

            if (color == CubeColor.Yellow)
            {
                return(ConsoleColor.Yellow);
            }

            throw new Exception("Color not expected");
        }
Example #13
0
        protected override bool CheckCube(Cube cube)
        {
            // check white face is solved
            for (int t = 0; t < 9; t++)
            {
                if (cube.At(CubeFace.UP, t) != CubeColor.WHITE)
                {
                    return(false);
                }
            }

            // check FTL is solved
            for (int f = 0; f < 4; f++)
            {
                CubeColor faceColor = Cube.GetFaceColor(MiddleLayerFaces[f]);
                for (int t = 3; t < 9; t++)
                {
                    if (cube.At(MiddleLayerFaces[f], t) != faceColor)
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Example #14
0
    void Initiate_sliced_cube(float half_current_scale)
    {
        GameObject sl_cube = Instantiate(sliced_cube) as GameObject;

        if (!is_direction_z)
        {
            sl_cube.transform.localScale = new Vector3(Mathf.Abs(half_current_scale * 2 - transform.localScale.x), new_step, half_current_scale_z * 2);
            if (transform.position.x > current_x)
            {
                sl_cube.transform.position = new Vector3(current_x + half_current_scale_x + 0.5f * sl_cube.transform.localScale.x, transform.position.y + new_step, transform.position.z);
            }
            else
            {
                sl_cube.transform.position = new Vector3(current_x - half_current_scale_x - 0.5f * sl_cube.transform.localScale.x, transform.position.y + new_step, transform.position.z);
            }
        }
        else
        {
            sl_cube.transform.localScale = new Vector3(half_current_scale_x * 2, new_step, Mathf.Abs(half_current_scale * 2 - transform.localScale.z));
            if (transform.position.z > current_z)
            {
                sl_cube.transform.position = new Vector3(current_x, transform.position.y + new_step, current_z + half_current_scale_z + 0.5f * sl_cube.transform.localScale.z);
            }
            else
            {
                sl_cube.transform.position = new Vector3(current_x, transform.position.y + new_step, current_z - half_current_scale_z - 0.5f * sl_cube.transform.localScale.z);
            }
        }

        sl_cube.GetComponent <Renderer>().material.SetColor("_Color", CubeColor.CurrentColor());
    }
Example #15
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;
 }
Example #16
0
        // is this even used?
        public static Tuple <bool, ColorCompare?> IsMatch(CubeColor color1, CubeColor color2, ColorCompare?start)
        {
            if ((color1 == CubeColor.Yellow && color2 == CubeColor.Yellow) || (color1 == CubeColor.None && color2 == CubeColor.None))
            {
                return(Tuple.Create <bool, ColorCompare?>(true, start));
            }
            if (color1 == CubeColor.Yellow || color1 == CubeColor.None || color2 == CubeColor.Yellow || color2 == CubeColor.None)
            {
                return(Tuple.Create <bool, ColorCompare?>(false, null));
            }
            var compare = CompareColors(color1, color2);

            if (start == null)
            {
                start = compare;
            }
            if (start == compare)
            {
                return(Tuple.Create <bool, ColorCompare?>(true, start));
            }
            else
            {
                return(Tuple.Create <bool, ColorCompare?>(false, null));
            }
        }
Example #17
0
        public void RotateVertical()
        {
            CubeColor temp = xColor;

            xColor = zColor;
            zColor = temp;
        }
Example #18
0
    public virtual void ToDeadlyColor(float overrideDuration = toColorDuration)
    {
        DisableAllColor(overrideDuration);

        if (deadlyParticle == null)
        {
            deadlyParticle = transform.GetChild(3).GetComponent <ParticleSystem>();
        }

        if (deadlyParticle2 == null)
        {
            deadlyParticle2 = transform.GetChild(4).GetComponent <ParticleSystem>();
        }

        deadlyParticle.Play();
        deadlyParticle2.Play();

        if (OnDeadly != null)
        {
            OnDeadly();
        }

        cubeMaterial.DOFloat(1f, "_LerpRED", overrideDuration).SetId("CubeColorTween" + gameObject.GetInstanceID()).SetUpdate(false);

        cubeColor = CubeColor.Deadly;
    }
Example #19
0
        public void RotateZ()
        {
            CubeColor temp = yColor;

            yColor = zColor;
            zColor = temp;
        }
Example #20
0
    private Color GetMaterialForColor(CubeColor color)
    {
        Color setColor = Color.white;

        switch (color)
        {
        case CubeColor.black:
            setColor = new Color(0.26f, 0.26f, 0.26f);
            break;

        case CubeColor.green:
            setColor = Color.green;
            break;

        case CubeColor.yellow:
            setColor = Color.yellow;
            break;

        case CubeColor.blue:
            setColor = Color.blue;
            break;

        case CubeColor.red:
            setColor = Color.red;
            break;

        case CubeColor.orange:
            setColor = new Color(1f, 0.6f, 0f);
            break;
        }
        return(setColor);
    }
Example #21
0
        public static String ColorToString(CubeColor color)
        {
            switch (color)
            {
            case CubeColor.White:
                return("W");

            case CubeColor.Red:
                return("R");

            case CubeColor.Blue:
                return("B");

            case CubeColor.Green:
                return("G");

            case CubeColor.Orange:
                return("O");

            case CubeColor.Yellow:
                return("Y");

            case CubeColor.Empty:
                return("?");
            }

            return("X");
        }
Example #22
0
        public Color CubeColorToColor(CubeColor cubeColor)
        {
            switch (cubeColor)
            {
            case CubeColor.Purple:
                return(colors[0]);

            case CubeColor.Yellow:
                return(colors[1]);

            case CubeColor.DarkGreen:
                return(colors[2]);

            case CubeColor.Orange:
                return(colors[3]);

            case CubeColor.LightGreen:
                return(colors[4]);

            case CubeColor.Pink:
                return(colors[5]);

            case CubeColor.Red:
                return(colors[6]);

            case CubeColor.Blue:
                return(colors[7]);

            case CubeColor.Cyan:
                return(colors[8]);

            default:
                return(colors[0]);
            }
        }
Example #23
0
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Check if the cube string s represents a solvable cube.
        // 0: Cube is solvable
        // -1: There is not exactly one facelet of each colour
        // -2: Not all 12 edges exist exactly once
        // -3: Flip error: One edge has to be flipped
        // -4: Not all corners exist exactly once
        // -5: Twist error: One corner has to be twisted
        // -6: Parity error: Two corners or two edges have to be exchanged
        //
        /// <summary>
        /// Check if the cube definition string s represents a solvable cube.
        /// </summary>
        /// <param name="s"> is the cube definition string , see <seealso cref="Facelet"/> </param>
        /// <returns> 0: Cube is solvable<br>
        ///         -1: There is not exactly one facelet of each colour<br>
        ///         -2: Not all 12 edges exist exactly once<br>
        ///         -3: Flip error: One edge has to be flipped<br>
        ///         -4: Not all 8 corners exist exactly once<br>
        ///         -5: Twist error: One corner has to be twisted<br>
        ///         -6: Parity error: Two corners or two edges have to be exchanged </returns>
        public static int verify(string s)
        {
            int[] count = new int[6];
            try
            {
                for (int i = 0; i < 54; i++)
                {
                    count[(int)CubeColor.Parse(typeof(CubeColor), i.ToString())]++;
                }
            }
            catch (Exception)
            {
                return(-1);
            }

            for (int i = 0; i < 6; i++)
            {
                if (count[i] != 9)
                {
                    return(-1);
                }
            }

            FaceCube  fc = new FaceCube(s);
            CubieCube cc = fc.toCubieCube();

            return(cc.verify());
        }
Example #24
0
 public TargetCubeData(TargetCubeData t)
 {
     this.Id = t.Id;
     this.horizontalPosition = t.horizontalPosition;
     this.vecticalPosition   = t.vecticalPosition;
     this.orientation        = t.orientation;
     this.cubeColor          = t.cubeColor;
 }
Example #25
0
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Construct a facelet cube from a string
 public FaceCube(string cubeString)
 {
     for (int i = 0; i < cubeString.Length; i++)
     {
         CubeColor col = (CubeColor)Enum.Parse(typeof(CubeColor), cubeString[i].ToString());
         f[i] = col;
     }
 }
Example #26
0
 private static Ellipse GenerateCircle(CubeColor cc)
 {
     // Initialize circle, that should be drawn over camera stream
     return(new Ellipse {
         Width = ReadRadius * 2 + 1,
         Height = ReadRadius * 2 + 1,
         Fill = Helper.ColorBrush(cc),
     });
 }
Example #27
0
    protected virtual IEnumerator WaitToChangeColorEnum(CubeColor whichColor, float waitTime)
    {
        yield return(new WaitForSeconds(waitTime * 0.5f));

        if (!hold)
        {
            cubeColor = whichColor;
        }
    }
Example #28
0
        /// <summary>
        /// Bring einen weißen falsch orientierten Kantenstein auf der mittleren Ebene in die richtige Position relativ zum Pivotstein.
        /// </summary>
        /// <param name="edge">Der Kantenstein, der in die richtige Position gebracht werden soll</param>
        protected void HandleFalseOrientatedStone(EdgeStone edge)
        {
            if (Array.TrueForAll(MiddleLayerFaces, f => edge.GetColorPosition(WHITE).Face != f) || edge.GetColorPosition(WHITE).Tile == 3 || edge.GetColorPosition(WHITE).Tile == 5)
            {
                throw new ArgumentOutOfRangeException("Der weiße Kantenstein muss sich in der oberen oder unteren Ebene befinden und die weiße Fläche muss auf einer der seitlichen Seiten (Orange, Grün, Rot, Blau) sein", nameof(edge));
            }

#if DEBUG
            Log.LogStuff("Handle false orientated stone\r\n\t" + edge.ToString());
#endif

            // get edge information
            CubeColor secndColor = GetSecondColor(edge);
            Position  whitePos   = edge.GetColorPosition(WHITE);

            // get face of white pos
            int middleLayerFaceID = Array.IndexOf(MiddleLayerFaces, whitePos.Face);
            // face in anti clockwise rotation of white position face
            CubeFace leftFace = MiddleLayerFaces[(middleLayerFaceID + 3) % 4];
            // face in clockwise roation of white position face
            CubeFace rightFace = MiddleLayerFaces[(middleLayerFaceID + 1) % 4];

            int leftDelta  = Math.Abs(SolvingUtility.NormalizeCount(SolvingUtility.GetDelta(secndColor, leftFace, UP), -1));
            int rightDelta = Math.Abs(SolvingUtility.NormalizeCount(SolvingUtility.GetDelta(secndColor, rightFace, UP), -1));

            // on up layer
            if (whitePos.Tile == 1)
            {
                // move edge to middle layer
                if (leftDelta < rightDelta)
                {
                    DoMove(whitePos.Face, -1);
                }
                else
                {
                    DoMove(whitePos.Face);
                }
                HandleStoneMiddleLayer(edge);
            }
            else
            {
                // check if the face must rotated back after stone handling
                int[] tiles   = { 3, 7, 5, 1 };
                bool  rotBack = cube.At(UP, tiles[middleLayerFaceID]) == WHITE;

                // move edge to middle layer
                int direction = leftDelta > rightDelta ? 1 : -1;
                DoMove(whitePos.Face, direction);

                HandleStoneMiddleLayer(edge);

                if (rotBack)
                {
                    DoMove(whitePos.Face, -direction);
                }
            }
        }
Example #29
0
 public static CubeColor GetRelativeColor(CubeColor col, ColorCompare rel)
 {
     if (!(col == CubeColor.Orange || col == CubeColor.Blue || col == CubeColor.Green || col == CubeColor.Red))
     {
         throw new ArgumentException("invalid cube color");
     }
     if (rel == ColorCompare.Same)
     {
         return(col);
     }
     if (rel == ColorCompare.Opposite)
     {
         if (col == CubeColor.Blue)
         {
             return(CubeColor.Green);
         }
         if (col == CubeColor.Green)
         {
             return(CubeColor.Blue);
         }
         if (col == CubeColor.Red)
         {
             return(CubeColor.Orange);
         }
         return(CubeColor.Red);
     }
     if (rel == ColorCompare.Right)
     {
         if (col == CubeColor.Orange)
         {
             return(CubeColor.Blue);
         }
         if (col == CubeColor.Blue)
         {
             return(CubeColor.Red);
         }
         if (col == CubeColor.Red)
         {
             return(CubeColor.Green);
         }
         return(CubeColor.Orange);
     }
     if (col == CubeColor.Orange)
     {
         return(CubeColor.Green);
     }
     if (col == CubeColor.Green)
     {
         return(CubeColor.Red);
     }
     if (col == CubeColor.Red)
     {
         return(CubeColor.Blue);
     }
     return(CubeColor.Orange);
 }
Example #30
0
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        public FaceCube()
        {
            string s = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB";

            for (int i = 0; i < 54; i++)
            {
                CubeColor col = (CubeColor)Enum.Parse(typeof(CubeColor), s[i].ToString());
                f[i] = col;
            }
        }
Example #31
0
        public void CubeParts_ShouldCoverTheWholeCubeWithoutOverlap()
        {
            //Arrange
            var testInternalPosition = new CubeColor[6, 3, 3];
            for (int i = 0; i < 6; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 3; k++)
                    {
                        testInternalPosition[i, j, k] = CubeColor.Undefined;
                    }
                }
            }
            //Act
            foreach (var part in Cube.Model.Impl.Cube.CubeParts)
            {
                testInternalPosition[(int)part.FirstPoint.Side - 1, (int)part.FirstPoint.Row - 1, (int)part.FirstPoint.Column - 1] = CubeColor.B;
                if (!default(Point).Equals(part.SecondPoint))
                {
                    testInternalPosition[(int)part.SecondPoint.Side - 1, (int)part.SecondPoint.Row - 1, (int)part.SecondPoint.Column - 1] = CubeColor.B;
                }
                if (!default(Point).Equals(part.ThirdPoint))
                {
                    testInternalPosition[(int)part.ThirdPoint.Side - 1, (int)part.ThirdPoint.Row - 1, (int)part.ThirdPoint.Column - 1] = CubeColor.B;

                }
            }
            //Assert
            for (int i = 0; i < 6; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 3; k++)
                    {
                        Assert.AreEqual(CubeColor.B, testInternalPosition[i, j, k]);
                    }
                }
            }
        }
Example #32
0
 public void TransformSideMirrorTopBottomAndLeftRight(CubeColor[, ,] sourceArray, CubeColor[, ,] targetArray, int sourceSideIndex, int targetSideIndex)
 {
     for (int i = 0; i < 3; i++)
     {
         for (int j = 0; j < 3; j++)
         {
             targetArray[targetSideIndex, 2 - i, 2 - j] = sourceArray[sourceSideIndex, i, j];
         }
     }
 }
Example #33
0
 public void TransformSideOneToOne(CubeColor[, ,] sourceArray, CubeColor[, ,] targetArray, int sourceSideIndex, int targetSideIndex)
 {
     for (int i = 0; i < 3; i++)
     {
         for (int j = 0; j < 3; j++)
         {
             targetArray[targetSideIndex, i, j] = sourceArray[sourceSideIndex, i, j];
         }
     }
 }
Example #34
0
        private static CubeColor[, ,] BuildInternalArrayForSolution()
        {
            var result = new CubeColor[6, 3, 3];
            //Side 1 --> y
            result[0, 0, 0] = CubeColor.Y; result[0, 0, 1] = CubeColor.Y; result[0, 0, 2] = CubeColor.Y;
            result[0, 1, 0] = CubeColor.Y; result[0, 1, 1] = CubeColor.Y; result[0, 1, 2] = CubeColor.Y;
            result[0, 2, 0] = CubeColor.Y; result[0, 2, 1] = CubeColor.Y; result[0, 2, 2] = CubeColor.Y;
            //Side 2 -- b
            result[1, 0, 0] = CubeColor.B; result[1, 0, 1] = CubeColor.B; result[1, 0, 2] = CubeColor.B;
            result[1, 1, 0] = CubeColor.B; result[1, 1, 1] = CubeColor.B; result[1, 1, 2] = CubeColor.B;
            result[1, 2, 0] = CubeColor.B; result[1, 2, 1] = CubeColor.B; result[1, 2, 2] = CubeColor.B;
            //Side 3 --> r
            result[2, 0, 0] = CubeColor.R; result[2, 0, 1] = CubeColor.R; result[2, 0, 2] = CubeColor.R;
            result[2, 1, 0] = CubeColor.R; result[2, 1, 1] = CubeColor.R; result[2, 1, 2] = CubeColor.R;
            result[2, 2, 0] = CubeColor.R; result[2, 2, 1] = CubeColor.R; result[2, 2, 2] = CubeColor.R;
            //Side 4 --> g
            result[3, 0, 0] = CubeColor.G; result[3, 0, 1] = CubeColor.G; result[3, 0, 2] = CubeColor.G;
            result[3, 1, 0] = CubeColor.G; result[3, 1, 1] = CubeColor.G; result[3, 1, 2] = CubeColor.G;
            result[3, 2, 0] = CubeColor.G; result[3, 2, 1] = CubeColor.G; result[3, 2, 2] = CubeColor.G;
            //Side 5 --> o
            result[4, 0, 0] = CubeColor.O; result[4, 0, 1] = CubeColor.O; result[4, 0, 2] = CubeColor.O;
            result[4, 1, 0] = CubeColor.O; result[4, 1, 1] = CubeColor.O; result[4, 1, 2] = CubeColor.O;
            result[4, 2, 0] = CubeColor.O; result[4, 2, 1] = CubeColor.O; result[4, 2, 2] = CubeColor.O;
            //Side 6 --> h
            result[5, 0, 0] = CubeColor.H; result[5, 0, 1] = CubeColor.H; result[5, 0, 2] = CubeColor.H;
            result[5, 1, 0] = CubeColor.H; result[5, 1, 1] = CubeColor.H; result[5, 1, 2] = CubeColor.H;
            result[5, 2, 0] = CubeColor.H; result[5, 2, 1] = CubeColor.H; result[5, 2, 2] = CubeColor.H;

            return result;
        }
Example #35
0
 private static void AssertAreEqualPositons(CubeColor[, ,] expected, CubeColor[, ,] actual)
 {
     Assert.IsNotNull(expected);
     Assert.IsNotNull(actual);
     for (int i = 0; i < 6; i++)
     {
         for (int j = 0; j < 3; j++)
         {
             for (int k = 0; k < 3; k++)
             {
                 Assert.AreEqual(expected[i, j, k], actual[i, j, k]);
             }
         }
     }
 }
Example #36
0
 public string ToPosition(CubeColor[, ,] internalPositionArray)
 {
     var builder = new StringBuilder();
     for (int i = 0; i < 6; i++)
     {
         for (int j = 0; j < 3; j++)
         {
             for (int k = 0; k < 3; k++)
             {
                 builder.Append(internalPositionArray[i, j, k]);
             }
         }
     }
     return m_positionHelper.ConvertLineToExternalFormat(builder.ToString().ToLower());
 }
Example #37
0
	void Start(){
		cc = GameObject.Find("ChangeColors").GetComponent<CubeColor>();
		if (!cc) {
			Debug.LogError ("Cannot find game object in scene 'ChangeColors'");
		}
	}
Example #38
0
    private void UpdateColor()
    {
        if (_lastFrameColor == cubeColor && _lastFrameState == cubeState) return;
        switch (cubeColor) {
          case CubeColor.Red:
        if (_redMaterial == null) {
          rend.material.color = Color.red;
        }
        else if (_metalRedMaterial != null) {
          if (cubeState == State.Player) {
            rend.material = _metalRedMaterial;
          }
          else rend.material = _redMaterial;
        }
        else rend.material = _redMaterial;
        break;

          case CubeColor.Green:
        if (_greenMaterial == null) {
          rend.material.color = Color.green;
        }
        else if (_metalGreenMaterial != null) {
          if (cubeState == State.Player) {
            rend.material = _metalGreenMaterial;
          }
          else rend.material = _greenMaterial;
        }
        else rend.material = _greenMaterial;
        break;

          case CubeColor.Blue:
        if (_blueMaterial == null) {
          rend.material.color = Color.blue;
        }
        else if (_metalBlueMaterial != null) {
          if (cubeState == State.Player) {
            rend.material = _metalBlueMaterial;
          }
          else rend.material = _blueMaterial;
        }
        else rend.material = _blueMaterial;
        break;

          case CubeColor.Yellow:
        if (_yellowMaterial == null) {
          rend.material.color = Color.yellow;
        }
        else if (_metalYellowMaterial != null) {
          if (cubeState == State.Player) {
            rend.material = _metalYellowMaterial;
          }
          else rend.material = _yellowMaterial;
        }
        else rend.material = _yellowMaterial;
        break;

          case CubeColor.Cyan:
        if (_cyanMaterial == null) {
          rend.material.color = Color.cyan;
        }
        else if (_metalCyanMaterial != null) {
          if (cubeState == State.Player) {
            rend.material = _metalCyanMaterial;
          }
          else rend.material = _cyanMaterial;
        }
        else rend.material = _cyanMaterial;
        break;

          case CubeColor.Magenta:
        if (_magentaMaterial == null) {
          rend.material.color = Color.magenta;
        }
        else if (_metalMagentaMaterial != null) {
          if (cubeState == State.Player) {
            rend.material = _metalMagentaMaterial;
          }
          else rend.material = _magentaMaterial;
        }
        else rend.material = _magentaMaterial;
        break;
        }
        _lastFrameColor = cubeColor;
    }
Example #39
0
        public void ValidateInternalPositionArray(CubeColor[, ,] position)
        {
            Dictionary<string, int> partColorsUsage = s_legalPartColors.ToDictionary(partColor => partColor, partColor => 0);
            //Check that all parts has legal color combinations
            foreach (var part in CubeParts)
            {
                var builder = new StringBuilder(3);
                builder.Append(position[(int)part.FirstPoint.Side - 1, (int)part.FirstPoint.Row - 1, (int)part.FirstPoint.Column - 1]);
                if (!default(Point).Equals(part.SecondPoint))
                {
                    builder.Append(position[(int)part.SecondPoint.Side - 1, (int)part.SecondPoint.Row - 1, (int)part.SecondPoint.Column - 1]);
                }
                if (!default(Point).Equals(part.ThirdPoint))
                {
                    builder.Append(position[(int)part.ThirdPoint.Side - 1, (int)part.ThirdPoint.Row - 1, (int)part.ThirdPoint.Column - 1]);

                }
                var sortedColors = builder.ToString().ToCharArray();
                Array.Sort(sortedColors);
                var partColors = new String(sortedColors);
                if (!partColorsUsage.ContainsKey(partColors))
                {
                    throw new InvalidPositionFormatException(string.Format("Invalid part color combination {0} in position", partColors));
                }
                partColorsUsage[partColors] = partColorsUsage[partColors] + 1;
            }
            //Check that all part color combinations has occured exactly once in the position
            if (!partColorsUsage.All(partColors => partColors.Value == 1))
            {
                throw new InvalidPositionFormatException("Duplicate or missing part color combination in position");
            }
            //Check that middle Y and H, B and G, R and O are placed on adjecent sides
            //Top - Bottom
            ValidateAdjecentMiddleParts(position[0, 1, 1], position[5, 1, 1]);
            //Left - Right
            ValidateAdjecentMiddleParts(position[1, 1, 1], position[3, 1, 1]);
            //Front - Back
            ValidateAdjecentMiddleParts(position[2, 1, 1], position[4, 1, 1]);
        }
Example #40
0
 private void TransformSideCounterClockWise(CubeColor[, ,] sourceArray, int sourceSideIndex)
 {
     CubeColor[, ,] firstSideBuffer = new CubeColor[1, 3, 3];
     firstSideBuffer[0, 0, 0] = sourceArray[sourceSideIndex, 0, 2];
     firstSideBuffer[0, 0, 1] = sourceArray[sourceSideIndex, 1, 2];
     firstSideBuffer[0, 0, 2] = sourceArray[sourceSideIndex, 2, 2];
     firstSideBuffer[0, 1, 0] = sourceArray[sourceSideIndex, 0, 1];
     firstSideBuffer[0, 1, 1] = sourceArray[sourceSideIndex, 1, 1];
     firstSideBuffer[0, 1, 2] = sourceArray[sourceSideIndex, 2, 1];
     firstSideBuffer[0, 2, 0] = sourceArray[sourceSideIndex, 0, 0];
     firstSideBuffer[0, 2, 1] = sourceArray[sourceSideIndex, 1, 0];
     firstSideBuffer[0, 2, 2] = sourceArray[sourceSideIndex, 2, 0];
     TransformSideOneToOne(firstSideBuffer, sourceArray, 0, sourceSideIndex);
 }
Example #41
0
 public void Turn(Direction direction)
 {
     // If direction = forward or backward
     //   Moving in and out of side.back (5)
     //     must be mirrored (left <-> right, and top <--> bottom)
     CubeColor[,,] firstSideBuffer = new CubeColor[1,3,3];
     switch (direction)
     {
         case Direction.Left:
             //  rotate top side clock wise and bottom side counter clock wise
             TransformSideOneToOne(m_internalPositionArray, firstSideBuffer, (int)Side.Left - 1, 0);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Front -1, (int)Side.Left - 1);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Right - 1, (int)Side.Front - 1);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Back - 1, (int)Side.Right- 1);
             TransformSideOneToOne(firstSideBuffer, m_internalPositionArray, 0, (int) Side.Back - 1);
             TransformSideClockWise(m_internalPositionArray, (int) Side.Top - 1);
             TransformSideCounterClockWise(m_internalPositionArray, (int) Side.Bottom - 1);
             break;
         case Direction.Right:
             //  rotate top side counter clock wise and bottom side clock wise
             TransformSideOneToOne(m_internalPositionArray, firstSideBuffer, (int)Side.Left - 1, 0);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Back - 1, (int)Side.Left- 1);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Right - 1, (int)Side.Back - 1);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Front -1, (int)Side.Right - 1);
             TransformSideOneToOne(firstSideBuffer, m_internalPositionArray, 0, (int) Side.Front - 1);
             TransformSideCounterClockWise(m_internalPositionArray, (int) Side.Top - 1);
             TransformSideClockWise(m_internalPositionArray, (int) Side.Bottom - 1);
             break;
         case Direction.Forward:
             // rotate left side clock wise and right side counter clock wise
             TransformSideOneToOne(m_internalPositionArray, firstSideBuffer, (int)Side.Top - 1, 0);
             TransformSideMirrorTopBottomAndLeftRight(m_internalPositionArray, m_internalPositionArray, (int)Side.Back - 1, (int)Side.Top - 1);
             TransformSideMirrorTopBottomAndLeftRight(m_internalPositionArray, m_internalPositionArray, (int)Side.Bottom - 1, (int)Side.Back - 1);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Front -1, (int)Side.Bottom - 1);
             TransformSideOneToOne(firstSideBuffer, m_internalPositionArray, 0, (int) Side.Front - 1);
             TransformSideClockWise(m_internalPositionArray, (int) Side.Left - 1);
             TransformSideCounterClockWise(m_internalPositionArray, (int)Side.Right - 1);
             break;
         case Direction.Backward:
             // rotate left side counter clock wise and right side clock wise
             TransformSideOneToOne(m_internalPositionArray, firstSideBuffer, (int)Side.Top - 1, 0);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Front -1, (int)Side.Top - 1);
             TransformSideOneToOne(m_internalPositionArray, m_internalPositionArray, (int)Side.Bottom - 1, (int)Side.Front - 1);
             TransformSideMirrorTopBottomAndLeftRight(m_internalPositionArray, m_internalPositionArray, (int)Side.Back - 1, (int)Side.Bottom - 1);
             TransformSideMirrorTopBottomAndLeftRight(firstSideBuffer, m_internalPositionArray, 0, (int)Side.Back - 1);
             TransformSideCounterClockWise(m_internalPositionArray, (int)Side.Left - 1);
             TransformSideClockWise(m_internalPositionArray, (int)Side.Right - 1);
             break;
         default:
             throw new ArgumentException(string.Format("Invalid direction value {0}", direction), "direction");
     }
 }
Example #42
0
 private static void ValidateAdjecentMiddleParts(CubeColor first, CubeColor second)
 {
     int diff = (int)first - (int)second;
     if (Math.Abs(diff) != 3)
     {
         throw new InvalidPositionFormatException(string.Format("Invalid adjecent middle parts {0} and {0} in position", first, second));
     }
 }
Example #43
0
 public CubeColor[, ,] ToInternalPositionArray(string position)
 {
     var result = new CubeColor[6, 3, 3];
     string[] lines = position.Split('\n');
     int linecount = 0;
     foreach (string fullLine in lines)
     {
         var line = fullLine.Trim().ToLower();
         if (line.Length > 0)
         {
             linecount++;
             int charcount = 0;
             foreach (var character in line)
             {
                 switch (character)
                 {
                     case 'y':
                     case 'b':
                     case 'r':
                     case 'g':
                     case 'o':
                     case 'h':
                         charcount++;
                         Point point = GetPoint(linecount, charcount);
                         CubeColor cubeColor;
                         Enum.TryParse(new string(new[] { character }), true, out cubeColor);
                         result[(int)point.Side - 1, (int)point.Row - 1, (int)point.Column - 1] = cubeColor;
                         break;
                     case ' ':
                         break;
                     default:
                         throw new InvalidPositionFormatException(string.Format("Invalid character {0} in position", character));
                 }
             }
         }
     }
     return result;
 }