public void TestRotationRight()
{
var cube = new RubiksCube();
cube.Rotate(CubeSlice.Right);
CheckSide(cube, CubeSide.Up, CubeColor.White, 6, CubeColor.Green, 3);
CheckSide(cube, CubeSide.Front, CubeColor.Green, 6, CubeColor.Yellow, 3);
CheckSide(cube, CubeSide.Down, CubeColor.Yellow, 6, CubeColor.Blue, 3);
CheckSide(cube, CubeSide.Back, CubeColor.Blue, 6, CubeColor.White, 3);
CheckSide(cube, CubeSide.Right, CubeColor.Red, 9);
CheckSide(cube, CubeSide.Left, CubeColor.Orange, 9);
}
public void TestAlgorithm2()
{
var cube = new RubiksCube();
cube.ExecAlgorithm("FRUR'U'F'");
CheckSide(cube, CubeSide.Up, Tuple(CubeColor.White, 5), Tuple(CubeColor.Blue, 1), Tuple(CubeColor.Green, 1), Tuple(CubeColor.Orange, 2));
CheckSide(cube, CubeSide.Front, Tuple(CubeColor.Green, 7), Tuple(CubeColor.Red, 1), Tuple(CubeColor.White, 1));
CheckSide(cube, CubeSide.Down, CubeColor.Yellow, 9);
CheckSide(cube, CubeSide.Back, Tuple(CubeColor.Blue, 7), Tuple(CubeColor.Red, 2));
CheckSide(cube, CubeSide.Right, Tuple(CubeColor.Red, 6), Tuple(CubeColor.White, 3));
CheckSide(cube, CubeSide.Left, Tuple(CubeColor.Orange, 7), Tuple(CubeColor.Blue, 1), Tuple(CubeColor.Green, 1));
}
public void TestAlgorithm()
{
var cube = new RubiksCube();
cube.ExecAlgorithm("(R R')(D' D)(U U')(F' F)(B B')(L L')");
CheckSide(cube, CubeSide.Up, CubeColor.White, 9);
CheckSide(cube, CubeSide.Front, CubeColor.Green, 9);
CheckSide(cube, CubeSide.Down, CubeColor.Yellow, 9);
CheckSide(cube, CubeSide.Back, CubeColor.Blue, 9);
CheckSide(cube, CubeSide.Right, CubeColor.Red, 9);
CheckSide(cube, CubeSide.Left, CubeColor.Orange, 9);
}
public void TestRotationMiddleDouble()
{
var cube = new RubiksCube();
cube.Rotate(CubeSlice.Middle, MoveDirection.Double);
CheckSide(cube, CubeSide.Up, Tuple(CubeColor.White, 6), Tuple(CubeColor.Yellow, 3));
CheckSide(cube, CubeSide.Front, Tuple(CubeColor.Green, 6), Tuple(CubeColor.Blue, 3));
CheckSide(cube, CubeSide.Down, Tuple(CubeColor.Yellow, 6), Tuple(CubeColor.White, 3));
CheckSide(cube, CubeSide.Back, Tuple(CubeColor.Blue, 6), Tuple(CubeColor.Green, 3));
CheckSide(cube, CubeSide.Right, Tuple(CubeColor.Red, 9));
CheckSide(cube, CubeSide.Left, Tuple(CubeColor.Orange, 9));
}
public void TestRotationEquatorInverted()
{
var cube = new RubiksCube();
cube.Rotate(CubeSlice.Equator, MoveDirection.Inverted);
CheckSide(cube, CubeSide.Up, Tuple(CubeColor.White, 9));
CheckSide(cube, CubeSide.Front, Tuple(CubeColor.Green, 6), Tuple(CubeColor.Red, 3));
CheckSide(cube, CubeSide.Down, Tuple(CubeColor.Yellow, 9));
CheckSide(cube, CubeSide.Back, Tuple(CubeColor.Blue, 6), Tuple(CubeColor.Orange, 3));
CheckSide(cube, CubeSide.Right, Tuple(CubeColor.Red, 6), Tuple(CubeColor.Blue, 3));
CheckSide(cube, CubeSide.Left, Tuple(CubeColor.Orange, 6), Tuple(CubeColor.Green, 3));
}
public cOGL(Control pb)
{
p = pb;
Width = p.Width;
Height = p.Height;
InitializeGL();
display_mod = 1;
rubiksCube = new RubiksCube();
backMirrorSurface = new Mirror(mirrorHeight, mirrorWidth, -mirrorWidth / 2, 0, -mirrorHeight / 2, 0, 0, 0, texture[0]);
rightMirrorSurface = new Mirror(mirrorHeight, mirrorWidth * 1.5, mirrorWidth / 2, 0, -mirrorHeight / 2, 0, -90, 0, texture[0]);
leftMirrorSurface = new Mirror(mirrorHeight, mirrorWidth * 1.5, -mirrorWidth / 2, 0, -mirrorHeight / 2, 0, -90, 0, texture[0]);
}
public static Color GetColor(this RubiksCube cube, TwoDPosition pos)
{
if (cube.CubeSize != 3)
{
throw new NotSupportedException("Currently we only draw 3x3x3 cubes two dimensionally :(");
}
Position threeDPosition = default(Position);
RubiksDirection direction = default(RubiksDirection);
if (_positionFaceMappings.ContainsKey(pos) && _positionMappings.ContainsKey(pos))
{
threeDPosition = _positionMappings[pos];
direction = _positionFaceMappings[pos];
}
RubiksColor?positionColor = cube[threeDPosition].GetColor(direction);
if (positionColor == null)
{
//oops
return(Colors.Gray);
}
switch (positionColor.Value)
{
case RubiksColor.Blue:
return(Colors.Blue);
case RubiksColor.Green:
return(Colors.Green);
case RubiksColor.Orange:
return(Colors.Orange);
case RubiksColor.Red:
return(Colors.Red);
case RubiksColor.White:
return(Colors.White);
case RubiksColor.Yellow:
return(Colors.Yellow);
default:
return(Colors.Gray);
}
}
public void InitializeAll()
{
if (cubePrefabMatrix != null)
{
cubePrefabMatrix.Clear();
foreach (Transform child in this.GetComponentInChildren <Transform>())
{
Destroy(child.gameObject);
}
}
RC = new RubiksCube();
InitializePrefabs();
RefreshPanels();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
RubiksCube selected = (RubiksCube)target;
rubiksRotation = (Rotation)EditorGUILayout.EnumPopup("Rotation", rubiksRotation);
if (!selected.turning)
{
if (GUILayout.Button("Turn Face"))
{
selected.Turn(rubiksRotation);
}
}
}
protected override void OnEnter()
{
remainingRandomMoveCount = Random.Range(RandomMoveCountMin, RandomMoveCountMax);
commandFinishedSubscriptionToken = MessengerHub.Subscribe <CommandCompleteMessage>(OnCommandFinished);
MessengerHub.Publish(new EnableCameraControlMessage(this));
RubiksCube.AnimateIn(() =>
{
lightLevelController.TurnOff(delay: 1f);
RotateRandomSlice();
});
}
public override void OnInspectorGUI()
{
cube = (RubiksCube)target;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Settings", EditorStyles.boldLabel);
DrawDefaultInspector();
if (GUILayout.Button("Generate"))
{
cube.GenerateCube();
}
if (GUILayout.Button("Shuffle"))
{
cube.Shuffle();
}
if (GUILayout.Button("Undo Last"))
{
cube.UndoLastMove();
}
if (GUILayout.Button("Undo All"))
{
cube.UndoAllMoves();
}
if (GUILayout.Button("Reset"))
{
cube.ResetCube();
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Rotate", EditorStyles.boldLabel);
if (cube.GeneratedCubeSize <= 0)
{
EditorGUILayout.HelpBox("Cube is not generated yet!", MessageType.Warning);
if (cube.transform.childCount > 0)
{
cube.ClearCube();
}
}
else
{
IndexSelectButtons();
SideButtons("X Axis", new RubiksCube.Move(new Vector3Int(1, 0, 0), selectedIndex));
SideButtons("Y Axis", new RubiksCube.Move(new Vector3Int(0, 1, 0), selectedIndex));
SideButtons("Z Axis", new RubiksCube.Move(new Vector3Int(0, 0, 1), selectedIndex));
}
}
public void Run_WhenNoExceptionThrown_ThenTheErrorStringIsNullAndWasThereAnErrorIsFalse()
{
RubiksCube cube = new RubiksCube();
Mock <ICubeSolvingAlgorithm> algMock = new Mock <ICubeSolvingAlgorithm>();
algMock.Setup(alg => alg.Solve(cube)).Callback(new Action(() =>
{
cube.TurnUp(TurningDirection.NineoClock);
}));
CubeRunner runner = new CubeRunner(cube, algMock.Object);
SolverResult result = runner.Run();
Assert.IsFalse(result.WasThereAnError);
Assert.IsNull(result.ErrorMessage);
}
public void Run_WhenAlgorithmTurnsCubeTwice_ThenMovesToCompletionIsTwo()
{
RubiksCube cube = new RubiksCube();
Mock <ICubeSolvingAlgorithm> algMock = new Mock <ICubeSolvingAlgorithm>();
algMock.Setup(alg => alg.Solve(cube)).Callback(new Action(() =>
{
cube.TurnUp(TurningDirection.NineoClock);
cube.TurnLeft(TurningDirection.NineoClock);
}));
CubeRunner runner = new CubeRunner(cube, algMock.Object);
SolverResult result = runner.Run();
Assert.AreEqual <int>(2, result.MovesToCompletion);
}
public void Run_WhenAlgorithmRunsForOneSecond_ThenTimeToCompletionIsOneSecondPlusOrMinusPointTwoSeconds()
{
RubiksCube cube = new RubiksCube();
Mock <ICubeSolvingAlgorithm> algMock = new Mock <ICubeSolvingAlgorithm>();
algMock.Setup(alg => alg.Solve(cube)).Callback(new Action(() =>
{
System.Threading.Thread.Sleep(1000);
}));
CubeRunner runner = new CubeRunner(cube, algMock.Object);
SolverResult result = runner.Run();
Assert.IsTrue(TimeSpan.FromSeconds(1) + TimeSpan.FromSeconds(.2) > result.TimeToCompletion ||
TimeSpan.FromSeconds(1) - TimeSpan.FromSeconds(.2) < result.TimeToCompletion, string.Format("Actual time to completion {0}", result.TimeToCompletion));
}
public void TestReset()
{
var cube = new RubiksCube();
cube.Rotate(CubeSlice.Back);
cube.Rotate(CubeSlice.Right);
cube.Rotate(CubeSlice.Down);
cube.Rotate(CubeSlice.Front);
cube.Rotate(CubeSlice.Left);
cube.Rotate(CubeSlice.Up);
cube.Reset();
CheckSide(cube, CubeSide.Up, Tuple(CubeColor.White, 9));
CheckSide(cube, CubeSide.Front, Tuple(CubeColor.Green, 9));
CheckSide(cube, CubeSide.Down, Tuple(CubeColor.Yellow, 9));
CheckSide(cube, CubeSide.Back, Tuple(CubeColor.Blue, 9));
CheckSide(cube, CubeSide.Right, Tuple(CubeColor.Red, 9));
CheckSide(cube, CubeSide.Left, Tuple(CubeColor.Orange, 9));
}
public void Run_WhenAlgorithmFailsToSolveCube_ThenResultShowThatTheCubeWasSolved()
{
RubiksCube cube = new RubiksCube();
cube.TurnLeft();
cube.TurnUp();
Mock <ICubeSolvingAlgorithm> algMock = new Mock <ICubeSolvingAlgorithm>();
algMock.Setup(alg => alg.Solve(cube)).Callback(new Action(() =>
{
cube.TurnUp(TurningDirection.NineoClock);
}));
CubeRunner runner = new CubeRunner(cube, algMock.Object);
SolverResult result = runner.Run();
Assert.IsFalse(result.WasCubeSolved);
}
public string Solve(RubiksCube rubiks, Color[] representedColors)
{
RubiksColor[,] rubiksCube = ReadRubiksColors(rubiks, representedColors);
StringBuilder solution = new StringBuilder();
solution.Append(SolveCross(rubiksCube));
Console.WriteLine(solution.ToString());
solution.Append(SolveFirstLayer(rubiksCube));
Console.WriteLine(solution.ToString());
solution.Append(SolveSecondLayer(rubiksCube));
Console.WriteLine(solution.ToString());
solution.Append(SolveTopCross(rubiksCube));
Console.WriteLine(solution.ToString());
solution.Append(SolveTopEdges(rubiksCube));
Console.WriteLine(solution.ToString());
solution.Append(SolvePermutateCorners(rubiksCube));
Console.WriteLine(solution.ToString());
solution.Append(SolveOrientCorners(rubiksCube));
return(solution.ToString());
}
public void Save()
{
string filePath = Constants.SETTINGS_FILE;
if (File.Exists(filePath))
{
FileStream clearedFile = File.Open(filePath, FileMode.Open);
clearedFile.SetLength(0);
clearedFile.Close();
}
StreamWriter stream = new StreamWriter(filePath, true);
Graphics.Save(stream);
Audio.Save(stream);
Controls.Save(stream);
RubiksCube.Save(stream);
stream.Close();
stream.Dispose();
}
private static void AssertRowTurn(RubiksCube cube, int rowIndex, bool isReverse)
{
if (rowIndex < 0)
{
throw new ArgumentOutOfRangeException(nameof(rowIndex));
}
var cubeFrontFace = cube.FrontFace;
var nextFace = isReverse
? cube.LeftFace
: cube.RightFace;
for (var i = 0; i < cube.Size; i++)
{
Assert.Equal(
cubeFrontFace.Slots[rowIndex, i]
.Color
, nextFace.CenterColor
);
}
}
public void TestGetPieces()
{
var cube = new RubiksCube();
var pieces = cube.GetPieces();
pieces.Count.Should().Be(26);
for (int x = 0; x <= 2; x++)
{
for (int y = 0; y <= 2; y++)
{
for (int z = 0; z <= 2; z++)
{
if (!(x == 1 && y == 1 && z == 1))
{
pieces.Count(p => p.Position.Equals(new Position {
X = x, Y = y, Z = z
})).Should().Be(1);
}
}
}
}
}
private bool IsCubeSolved(RubiksCube cube)
{
int cubeSize = cube.CubeSize;
RubiksCube solvedCube = new RubiksCube(cubeSize);
for (int x = 0; x < cubeSize; x++)
{
for (int y = 0; y < cubeSize; y++)
{
for (int z = 0; z < cubeSize; z++)
{
Cubie actualCubie = cube[x, y, z];
Cubie expectedCubie = solvedCube[x, y, z];
if (!actualCubie.Equals(expectedCubie))
{
return(false);
}
}
}
}
return(true);
}
private void initCube()
{
RC = new RubiksCube();
int actualCubeNumber = 0;
cubeBrickPrefabMatrix = new List <List <List <GameObject> > >();
for (int x = 0; x < 3; x++)
{
List <List <GameObject> > PrefabRow = new List <List <GameObject> >();
for (int y = 0; y < 3; y++)
{
List <GameObject> PrefabColumn = new List <GameObject>();
for (int z = 0; z < 3; z++)
{
//Instantiate(CubeBrickPrefab, new Vector3(x + 0.5f,y + 0.5f,z +0.5f), Quaternion.identity);
GameObject cubeBrickPrefab = Instantiate(CubeBrickPrefab, Vector3.zero, Quaternion.identity) as GameObject;
cubeBrickPrefab.transform.SetParent(transform.parent);
cubeBrickPrefab.transform.position = new Vector3(x, y, z) * spacing;
// used for set the main Object, the camera will lookAt
if (actualCubeNumber == 14)
{
CameraTrigger.cameraObject = cubeBrickPrefab;
}
//Debug.Log(cubeBrickPrefab.GetInstanceID());
//setColorForBrickPrefab(cubeBrickPrefab);
PrefabColumn.Add(cubeBrickPrefab);
actualCubeNumber++;
}
PrefabRow.Add(PrefabColumn);
}
cubeBrickPrefabMatrix.Add(PrefabRow);
}
}
//复制相同的方块
public RubiksCube copyCube()
{
RubiksCube rCube = new RubiksCube(new GameControl());
rCube.gameControl.record = gameControl.record;
for (int i = 0; i < cubeLength; i++)
{
for (int j = 0; j < cubeLength; j++)
{
for (int k = 0; k < cubeLength; k++)
{
Unit cube = new Unit();
for (int r = 0; r < 6; r++)
{
Color color = gameControl.cubeMatrix [i] [j] [k].getColor((Unit.faces)r);
cube.setColor((Unit.faces)r, color);
}
rCube.gameControl.cubeMatrix[i][j][k] = cube;
}
}
}
return(rCube);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
//spriteBatch = new SpriteBatch(GraphicsDevice);
_animator = new Animator(30f); //interval: 30ms
Factory.GraphicsDevice = graphics.GraphicsDevice;
_rubikscube = RubiksCube.CreateRubiksCube(new Point3()
{
X = 0, Y = 0, Z = 0
}, 10, _animator);
/*
* Matrix[] modelTransforms;
* _rubikscube.InitModel(XNAUtils.LoadModelWithBoundingSphere(out modelTransforms, "rubik_cube-XNA", Content));
*/
_rubikscube.OneOpDone = RubiksCube_OneOpDone;
_rubikscube.Random();
// TODO: use this.Content to load your game content here
}
//解决魔方
public void Slove()
{
Debug.Log("Solve");
if (numerator != null)
{
StopCoroutine(numerator);
}
RubiksCube rCube = cPrefab.rubiksCube.copyCube();
solution = new Solution(rCube);
string sol = solution.Solutions();
//GameControl gameControl = new GameControl();
//RubiksCube solCube = new RubiksCube (gameControl);
//solCube.RunCustomFormula (sol);
numerator = cPrefab.processStep(sol);
StartCoroutine(numerator);
Debug.Log(sol);
totalLink = "";
reverseScrambleLink = "";
}
// Use this for initialization
void Start()
{
rubiks_cube_ = new RubiksCube();
cube_prefab_matrix_ = new List <List <List <GameObject> > >();
for (int i = 0; i < 3; i++)
{
List <List <GameObject> > prefab_rows_ = new List <List <GameObject> >();
for (int j = 0; j < 3; j++)
{
List <GameObject> prefab_columns_ = new List <GameObject>();
for (int k = 0; k < 3; k++)
{
GameObject temp_cube_prefab_ = Instantiate(cube_prefab_, Vector3.zero, Quaternion.identity) as GameObject;
temp_cube_prefab_.transform.SetParent(transform);
temp_cube_prefab_.transform.position = new Vector3((i - 1), (j - 1), (k - 1)) * 1.05f;
prefab_columns_.Add(temp_cube_prefab_);
}
prefab_rows_.Add(prefab_columns_);
}
cube_prefab_matrix_.Add(prefab_rows_);
}
}
private void Init()
{
Viewport3D viewport = new Viewport3D();
_viewport = viewport;
cubePanel.Children.Add(viewport);
PerspectiveCamera camera = new PerspectiveCamera();
_camera = camera;
viewport.Camera = camera;
camera.Position = new Point3D(30, 30, 30);
camera.LookDirection = new Vector3D(-1, -1, -1);
camera.UpDirection = new Vector3D(0, 1, 0);
camera.FieldOfView = 90;
CubeConfiguration.Factory = new Factory();
_rubikscube = RubiksCube.CreateRubiksCube(new Point3(), 10);
ModelVisual3D model = ((CubeModel)_rubikscube.Model).ModelVisual;
Model3DGroup group = (Model3DGroup)model.Content;
viewport.Children.Add(model);
foreach (IMesh mesh in _rubikscube.Meshes)
{
group.Children.Add(((CubieMesh)mesh).Geometry);
}
_rubikscube.OneOpDone = RubiksCube_OneOpDone;
_rubikscube.Random();
_model = model;
CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
}
public MainForm()
{
InitializeComponent();
canvas.Projection = MatrixHelper.CreatePerspectiveFieldOfView(
(float)Math.PI / 4, canvas.Viewport.AspectRatio, 1, 1000);
canvas.Camera = new Camera(new Vector3(0, 0, 500));
cube = new RubiksCube(10);
cube.World *= MatrixHelper.CreateScale(100);
rotationCursor = new Sphere(125f * 0.3f / cube.Size, Color.Cyan);
canvas.GraphicsDevice.Lights.Add(new PointLight(new Vector3(150), 4.5f, Color.White));
canvas.GraphicsDevice.Lights.Add(new PointLight(new Vector3(-150), 4.5f, Color.White));
//canvas.GraphicsDevice.LightingEnabled = true;
canvas.GraphicsDevice.CullMode = CullMode.CullCounterClockwiseFace;
lastUpdateTime = DateTime.Now;
Application.Idle += Application_Idle;
canvas.Select();
}
// Use this for initialization
void Start()
{
RC = new RubiksCube();
cubePrefabMatrix = new List <List <List <GameObject> > >();
for (int x = 0; x < 3; x++)
{
List <List <GameObject> > PrefabRow = new List <List <GameObject> >();
for (int y = 0; y < 3; y++)
{
List <GameObject> PrefabColumn = new List <GameObject>();
for (int z = 0; z < 3; z++)
{
GameObject cubePrefab = Instantiate(CubePrefab, Vector3.zero, Quaternion.identity) as GameObject;
cubePrefab.transform.SetParent(transform);
cubePrefab.transform.position = new Vector3((x - 1), (y - 1), (z - 1)) * spacing;
//cubePrefab.GetComponent<CubePrefab>().refreshPanels(RC.cubeMatrix[x][y][z]);
PrefabColumn.Add(cubePrefab);
}
PrefabRow.Add(PrefabColumn);
}
cubePrefabMatrix.Add(PrefabRow);
}
}
public RubiksCube cloneCube()
{
RubiksCube RC = new RubiksCube();
RC.turnRecord = turnRecord;
for (int x = 0; x < 3; x++)
{
for (int y = 0; y < 3; y++)
{
for (int z = 0; z < 3; z++)
{
Cube tempCube = new Cube();
for (int i = 0; i < 6; i++)
{
Color tempc = cubeMatrix[x][y][z].getColor((Cube.sides)i);
tempCube.setSideColor((Cube.sides)i, tempc);
}
RC.cubeMatrix[x][y][z] = tempCube;
}
}
}
return(RC);
}
public Solver(RubiksCube RC)
{
RCube = RC;
}
void DFS_InitialCheck(int depth, int depthLimit, RubiksCube parent, List<RubiksCube> tree)
{
string[] operations = { "R", "L", "U", "D", "F", "B" };//each operation also has an inverse
for (int i = 0; i < operations.Length; i++)
{
RubiksCube tempRC = parent.cloneCube();
tempRC.RunCustomSequence(operations[i]);
if (depth == depthLimit)
tree.Add(tempRC);
else
DFS_InitialCheck(depth + 1, depthLimit, tempRC, tree);
RubiksCube tempRC2 = parent.cloneCube();
tempRC2.RunCustomSequence(operations[i] + "i");
if (depth == depthLimit)
tree.Add(tempRC2);
else
DFS_InitialCheck(depth + 1, depthLimit, tempRC2, tree);
}
}
public string SearchedSolution()
{
if (RCube.isSolved())
return "";//cube is already solved. Quit
//check for easy solutions
//check if checkerboard pattern solves it
RubiksCube tempRC = RCube.cloneCube();
tempRC.RunSequence(10);
if (tempRC.isSolved())
return RCube.sequences[10];
//check if dot patter solves it
tempRC = RCube.cloneCube();
string tempsol = "";
for (int i = 0; i < 3; i++)
{
tempRC.RunSequence(11);
tempsol += RCube.sequences[11];
if (tempRC.isSolved())
return tempsol;
}
RCube.clearTurnRecord();
//reorient the cube so that white is on top
if (RCube.cubeMatrix[1][2][1].getColor(Cube.sides.TOP) != Cube.WHITECOLOR)
{
if (RCube.cubeMatrix[1][2][1].getColor(Cube.sides.TOP) == Cube.YELLOWCOLOR)
{
RCube.turnCubeZ(true);
RCube.turnCubeZ(true);
}
else
{
while (RCube.cubeMatrix[1][1][0].getColor(Cube.sides.TOP) != Cube.WHITECOLOR)
{ RCube.turnCubeY(true); }//turn the cube until the front is white
RCube.turnCubeX(false);
}
}
//run initial dfs check to maybe find easy solutions in 4 turns or less
List<RubiksCube> dfsTree = new List<RubiksCube>();
for (int i = 0; i < 3; i++)
{
DFS_InitialCheck(0, i, RCube.cloneCube(), dfsTree);
for (int j = 0; j < dfsTree.Count; j++)
{
if (dfsTree[j].isSolved())
return dfsTree[j].turnRecord;
}
}
//begin running actual solution with intermediate dfs optimization
dfsTree = new List<RubiksCube>();
DFS_Stage2(0, null, RCube.cloneCube(), dfsTree);
int minCost = 9999;
int minCostIndex = 0;
for (int i = 0; i < dfsTree.Count; i++)
{
int cost = dfsTree[i].TurnRecordTokenCount();
if (cost < minCost)
{
minCost = cost;
minCostIndex = i;
}
}
RCube = dfsTree[minCostIndex].cloneCube();
//start stage 3 DFS
dfsTree = new List<RubiksCube>();
DFS_Stage3(0, null, RCube.cloneCube(), dfsTree);
minCost = 9999;
minCostIndex = 0;
for (int i = 0; i < dfsTree.Count; i++){
int cost = dfsTree[i].TurnRecordTokenCount();
if (cost < minCost)
{
minCost = cost;
minCostIndex = i;
}
}
RCube = dfsTree[minCostIndex].cloneCube();
//flip cube
RCube.turnCubeZ(true);
RCube.turnCubeZ(true);
//start stage 4 DFS
dfsTree = new List<RubiksCube>();
DFS_Stage4(0, null, RCube.cloneCube(), dfsTree);
minCost = 9999;
minCostIndex = 0;
for (int i = 0; i < dfsTree.Count; i++)
{
int cost = dfsTree[i].TurnRecordTokenCount();
if (cost < minCost)
{
minCost = cost;
minCostIndex = i;
}
}
RCube = dfsTree[minCostIndex].cloneCube();
Stage5();
Stage6();
RCube.turnCubeZ(true);
RCube.turnCubeZ(true);
return RCube.turnRecord;
}
// Use this for initialization
void Start()
{
RC = new RubiksCube();
cubePrefabMatrix = new List<List<List<GameObject>>>();
for (int x = 0; x < 3; x++)
{
List<List<GameObject>> PrefabRow = new List<List<GameObject>>();
for (int y = 0; y < 3; y++)
{
List<GameObject> PrefabColumn = new List<GameObject>();
for (int z = 0; z < 3; z++)
{
GameObject cubePrefab = Instantiate(CubePrefab, Vector3.zero, Quaternion.identity) as GameObject;
cubePrefab.transform.SetParent(transform);
cubePrefab.transform.position = new Vector3((x - 1), (y - 1), (z - 1)) * spacing;
//cubePrefab.GetComponent<CubePrefab>().refreshPanels(RC.cubeMatrix[x][y][z]);
PrefabColumn.Add(cubePrefab);
}
PrefabRow.Add(PrefabColumn);
}
cubePrefabMatrix.Add(PrefabRow);
}
}
void DFS_Stage4(int depth, List<Color> RemainingColors, RubiksCube parent, List<RubiksCube> tree)
{
//Debug.Log("Depth: " + depth);
if (depth == 0)//first iteration
{
RemainingColors = new List<Color>();
RemainingColors.Add(Cube.REDCOLOR);
RemainingColors.Add(Cube.GREENCOLOR);
RemainingColors.Add(Cube.ORANGECOLOR);
RemainingColors.Add(Cube.BLUECOLOR);
}
for (int i = 0; i < RemainingColors.Count; i++)
{
RubiksCube tempRC = parent.cloneCube();
tempRC.turnCubeToFaceRGBOColorWithYellowOrWhiteOnTop(RemainingColors[i]);
SolveMiddleRowSideCubes(tempRC);
List<Color> newRemainingColors = new List<Color>();
for (int j = 0; j < RemainingColors.Count; j++) { newRemainingColors.Add(RemainingColors[j]); }
newRemainingColors.RemoveAt(i);
if (newRemainingColors.Count == 0)
{
tree.Add(tempRC);
return;
}
else
DFS_Stage4(depth + 1, newRemainingColors, tempRC, tree);
}
return;
}
void SolveMiddleRowSideCubes(RubiksCube RC)
{
Color TargetColorA = RC.cubeMatrix[1][1][0].getColor(Cube.sides.FRONT);//front center
Color TargetColorB = RC.cubeMatrix[2][1][1].getColor(Cube.sides.RIGHT);//right center
//Debug.Log("TargetColors: " + TargetColorA + TargetColorB);
Vector3 Pos = RC.sideCubeWithColors(TargetColorA, TargetColorB);
//Debug.Log("Pos: " + Pos);
Vector3 TargetPos = new Vector3(2, 1, 0);
//Debug.Log("TargetPos: " + TargetPos);
if (Pos != TargetPos || RC.cubeMatrix[(int)TargetPos.x][(int)TargetPos.y][(int)TargetPos.z].getColor(Cube.sides.FRONT) != TargetColorA)
{//cube is not in the right place or is oriented wrong
if (Pos.y != 2)//not in the top
{
if (Pos.z == 0)//front
{
if (Pos.x == 0)//front left middle row
RC.RunSequence(3);//force the cube out of 0,1,0
else if (Pos.x == 2)//front right middle row
RC.RunSequence(2);//force the cube out of 2,1,0
}
else
{
RC.turnCubeY(true);
RC.turnCubeY(true);
if (Pos.x == 0)//front left middle row
RC.RunSequence(2);//force the cube out of 0,1,0
else if (Pos.x == 2)//front right middle row
RC.RunSequence(3);//force the cube out of 2,1,0
RC.turnCubeY(true);
RC.turnCubeY(true);
}
}
//cube is now guaranteed to be in top row
Pos = RC.sideCubeWithColors(TargetColorA, TargetColorB);
while (Pos != new Vector3(1, 2, 0))
{
RC.rotateTopFace(true);
Pos = RC.sideCubeWithColors(TargetColorA, TargetColorB);
}
//cube is now in 1,2,0
if (RC.cubeMatrix[(int)Pos.x][(int)Pos.y][(int)Pos.z].getColor(Cube.sides.FRONT) != TargetColorA)
{
RC.rotateTopFace(false);
RC.turnCubeY(false);
RC.RunSequence(3);
RC.turnCubeY(true);
}
else
{
RC.RunSequence(2);
}
}
//cube is now in the target pos and is oriented correctly
}
void SolveWhiteCornerCube(RubiksCube RC)
{
Color TargetColorA = RC.cubeMatrix[1][1][0].getColor(Cube.sides.FRONT);//front center
Color TargetColorB = RC.cubeMatrix[2][1][1].getColor(Cube.sides.RIGHT);//right center
//Debug.Log("TargetColors: " + TargetColorA + TargetColorB);
Vector3 Pos = RC.cornerCubeWithColors(TargetColorA, TargetColorB, Cube.WHITECOLOR);
//Debug.Log("Pos: " + Pos);
Vector3 TargetPos = new Vector3(2, 2, 0);
//Debug.Log("TargetPos: " + TargetPos);
if (TargetPos != Pos)//not in the right spot
{
if (Pos.y == 2)//in the top but in the wrong spot
{
if (Pos.z == 0)//top front left pos
{
RC.rotateLeftFace(true);
RC.rotateBottomFace(true);
RC.rotateLeftFace(false);
}
if (Pos.z == 2)//top back left or top back right
{
if (Pos.x == 0)
{
RC.rotateLeftFace(false);
RC.rotateBottomFace(true);
RC.rotateLeftFace(true);
}
if (Pos.x == 2)
{
RC.rotateRightFace(true);
RC.rotateBottomFace(true);
RC.rotateRightFace(false);
}
}
}
//cube is now on the bottom
Pos = RC.cornerCubeWithColors(TargetColorA, TargetColorB, Cube.WHITECOLOR);
while (Pos != new Vector3(2, 0, 0))
{
RC.rotateBottomFace(true);
Pos = RC.cornerCubeWithColors(TargetColorA, TargetColorB, Cube.WHITECOLOR);
}
//cube should now be directly below it's target position or already in target position
}
while (true)
{
Pos = RC.cornerCubeWithColors(TargetColorA, TargetColorB, Cube.WHITECOLOR);
Cube tempCube = RC.cubeMatrix[(int)Pos.x][(int)Pos.y][(int)Pos.z];
if (Pos == TargetPos && tempCube.getColor(Cube.sides.FRONT) == TargetColorA && tempCube.getColor(Cube.sides.TOP) == Cube.WHITECOLOR)
break;
RC.RunSequence(1);
}
}
void SolveWhiteSideCube(RubiksCube RC)
{
Color TargetColor = RC.cubeMatrix[1][1][0].getColor(Cube.sides.FRONT);
//Debug.Log("TargetColor: " + TargetColor);
Vector3 Pos = RC.sideCubeWithColors(TargetColor, Cube.WHITECOLOR);
//Debug.Log("Pos: " + Pos);
Vector3 TargetPos = new Vector3(1, 2, 0);
//Debug.Log("TargetPos: " + TargetPos);
if (TargetPos != Pos)//if the cube is not where it should be
{
if (Pos.y == 2)//is on top row
{
if (Pos.x == 0)
{
RC.rotateLeftFace(true);
}
else if (Pos.x == 2)
{
RC.rotateRightFace(false);
}
else if (Pos.x == 1)
{
RC.rotateBackFace(true);
RC.rotateBackFace(true);
}
}
else if (Pos.y == 1 && Pos.z == 2)//middle row on the back
{
if (Pos.x == 0)
{
RC.rotateBackFace(true);
RC.rotateBottomFace(true);
RC.rotateBackFace(false);
}
if (Pos.x == 2)
{
RC.rotateBackFace(false);
RC.rotateBottomFace(true);
RC.rotateBackFace(true);
}
}
//cube is now on bottom or front
//requery pos
Pos = RC.sideCubeWithColors(TargetColor, Cube.WHITECOLOR);
if (Pos.y == 0)//is on bottom
{
while (Pos.z != 0)//while cube is not on the bottom
{
RC.rotateBottomFace(true);
Pos = RC.sideCubeWithColors(TargetColor, Cube.WHITECOLOR);
}
}
while (Pos.y != 2)
{
RC.rotateFrontFace(true);
Pos = RC.sideCubeWithColors(TargetColor, Cube.WHITECOLOR);
}
}
//cube is now where it should be
Cube temp = RC.cubeMatrix[(int)TargetPos.x][(int)TargetPos.y][(int)TargetPos.z];
if (temp.getColor(Cube.sides.TOP) != Cube.WHITECOLOR)
{
RC.turnCubeY(true);
RC.RunSequence(0);
RC.turnCubeY(false);
}
}
public RubiksCube cloneCube()
{
RubiksCube RC = new RubiksCube();
RC.turnRecord = turnRecord;
for (int x = 0; x < 3; x++)
{
for (int y = 0;y < 3; y++)
{
for (int z = 0; z < 3; z++)
{
Cube tempCube = new Cube();
for (int i = 0; i < 6; i++)
{
Color tempc = cubeMatrix[x][y][z].getColor((Cube.sides)i);
tempCube.setSideColor((Cube.sides)i, tempc);
}
RC.cubeMatrix[x][y][z] = tempCube;
}
}
}
return RC;
}
