private static void StackSolver(BlockPuzzle blockPuzzle, BlockLine.Orientation nextOrientation)
{
if (!blockPuzzle.isFinished)
{
if (blockPuzzle.AddBlockLine(nextOrientation))
{
StackSolver(blockPuzzle, BlockLine.Orientation.Left);
StackSolver(blockPuzzle, BlockLine.Orientation.Right);
StackSolver(blockPuzzle, BlockLine.Orientation.Up);
StackSolver(blockPuzzle, BlockLine.Orientation.Down);
StackSolver(blockPuzzle, BlockLine.Orientation.Front);
StackSolver(blockPuzzle, BlockLine.Orientation.Back);
blockPuzzle.RemoveLastBlockLine();
}
}
}
// This part does the work and is called link by link
private static void PuzzleSolverInnerLoop(BlockPuzzle blockPuzzle, BlockLine.BlockLineOrientation nextOrientation)
{
// If you're not done, keep working!
if (!blockPuzzle.IsFinished)
{
// Try to add the requested orientation
if (blockPuzzle.AddBlockLine(nextOrientation))
{
// If adding the requested block succeeds, try to add another block in each direction!
PuzzleSolverInnerLoop(blockPuzzle, BlockLine.BlockLineOrientation.Left);
PuzzleSolverInnerLoop(blockPuzzle, BlockLine.BlockLineOrientation.Right);
PuzzleSolverInnerLoop(blockPuzzle, BlockLine.BlockLineOrientation.Up);
PuzzleSolverInnerLoop(blockPuzzle, BlockLine.BlockLineOrientation.Down);
PuzzleSolverInnerLoop(blockPuzzle, BlockLine.BlockLineOrientation.Front);
PuzzleSolverInnerLoop(blockPuzzle, BlockLine.BlockLineOrientation.Back);
// Once all directions have been tried, unroll the block you just placed from the master list
blockPuzzle.RemovePreviousBlockLine();
}
}
}
// Start off by enumerating all the starting positions and adding them to the list
public static void Solve(BlockPuzzle blockPuzzle)
{
bool blockAdded = false;
bool solutionFound = false;
uint solutionCount = 0;
// These are the unique starting points
// all other starting points are equivalent by symmetry in a 4x4x4 cube
// TODO: Build up a general model for unique starting points for cube size n
// NOTE: This will spit out some solutions that are mirrors of each other. Although they're still "unique",
// future work would be to prune out the mirrors.
// (Ex: "start in the corner (0,0,0) and move left" is rotationally symmetric to "start in the corner (0,0,0) and move right")
// (Ex: "start at 0,1,0, move up, then left" is vertically symmetric to "start at 0,1,0, move up, then right"
List <Point> startingPoints = new List <Point>()
{
new Point(0, 0, 0),
new Point(0, 1, 0),
new Point(1, 1, 0),
new Point(1, 1, 1),
};
// for each starting point, kick off the inner solver
foreach (Point startingPoint in startingPoints)
{
// Start time
System.Console.WriteLine("Beginning pass with start point {0}, {1}, {2} at {3}. ====================",
startingPoint.XPos, startingPoint.YPos, startingPoint.ZPos, System.DateTime.Now.ToLongTimeString());
// Update the starting point for the puzzle and the first block line
blockPuzzle.StartingPoint = startingPoint;
blockPuzzle.BlockLineList[0].StartPoint = startingPoint;
// Since that's the starting point and we *know* that a block will be there, set that block in the grid
blockPuzzle.TheGrid[blockPuzzle.StartingPoint.XPos, blockPuzzle.StartingPoint.YPos, blockPuzzle.StartingPoint.ZPos] = true;
// Reset the starting link and orientation
blockPuzzle.BlockLineIndex = 0;
blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex].ZeroOrientation(); // no prior orientation
// This is the main loop!
while (blockPuzzle.BlockLineIndex >= 0)
{
// Try the next link and orientation. Does it fit? If so, add it in!
blockAdded = blockPuzzle.AddBlockLine(blockPuzzle.BlockLineIndex);
if (blockAdded)
{
// increment the link index
blockPuzzle.BlockLineIndex++;
// Are we done? Is that the last block? IS THAT A SOLUTION???
solutionFound = blockPuzzle.BlockLineIndex >= blockPuzzle.BlockLineList.Count;
if (solutionFound)
{
Console.WriteLine("Solution #" + (solutionCount++ + 1) + " ================================================================"); // Add one to start with "Solution 1"
blockPuzzle.PrintPuzzle();
// special last block line case, take the index back down to the last block
blockPuzzle.BlockLineIndex--;
}
// if not, reset the new link's start pos and orientation in light of the last link's orientation
else
{
blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex].StartPoint = blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex - 1].EndPoint;
blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex].LastLineOrientation = blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex - 1].Orientation;
blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex].ZeroOrientation();
}
}
// if the blockline couldn't be added OR we found a solution, rotate the block line in question in prep for next attempt
if (!blockAdded || solutionFound)
{
// rotate the link
if (blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex].RotateBlockLine())
{
// exit this loop, go back up to the top of the loop, and try again!
}
// if that was the last rotation, there are no more options for this link. back up one link and rotate
else
{
do
{
// back up one
--(blockPuzzle.BlockLineIndex);
}while ((blockPuzzle.BlockLineIndex >= 0) && // as long as you're not past the beginning
(!blockPuzzle.BlockLineList[blockPuzzle.BlockLineIndex].RotateBlockLine())); // rotate and check, until there are no more rotates
}
}
}
// Clean up the starting point that we added in the beginning
blockPuzzle.TheGrid[blockPuzzle.StartingPoint.XPos, blockPuzzle.StartingPoint.YPos, blockPuzzle.StartingPoint.ZPos] = false;
// End time
System.Console.WriteLine("Ending pass with start point {0}, {1}, {2} at {3}. =======================",
startingPoint.XPos, startingPoint.YPos, startingPoint.ZPos, System.DateTime.Now.ToLongTimeString());
}
}