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; } }
private void FlipB() { CubeColor temp = BU; BU = UB; UB = temp; }
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); }
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"); }
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; } }
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; } }
/// <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; }
/// <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)); }
public void RotateHorizontal() { CubeColor temp = xColor; xColor = yColor; yColor = temp; }
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; } }
/// <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); }
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"); }
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); }
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()); }
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; }
// 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)); } }
public void RotateVertical() { CubeColor temp = xColor; xColor = zColor; zColor = temp; }
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; }
public void RotateZ() { CubeColor temp = yColor; yColor = zColor; zColor = temp; }
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); }
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"); }
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]); } }
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // 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()); }
public TargetCubeData(TargetCubeData t) { this.Id = t.Id; this.horizontalPosition = t.horizontalPosition; this.vecticalPosition = t.vecticalPosition; this.orientation = t.orientation; this.cubeColor = t.cubeColor; }
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // 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; } }
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), }); }
protected virtual IEnumerator WaitToChangeColorEnum(CubeColor whichColor, float waitTime) { yield return(new WaitForSeconds(waitTime * 0.5f)); if (!hold) { cubeColor = whichColor; } }
/// <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); } } }
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); }
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 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; } }
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]); } } } }
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]; } } }
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]; } } }
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; }
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]); } } } }
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()); }
void Start(){ cc = GameObject.Find("ChangeColors").GetComponent<CubeColor>(); if (!cc) { Debug.LogError ("Cannot find game object in scene 'ChangeColors'"); } }
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; }
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]); }
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); }
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"); } }
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)); } }
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; }