public PuzzleGrid InitGrid()
{ //Randomly fill in the first row and column of puzzlegrid
PuzzleGrid tempGrid = new PuzzleGrid {
}; //temporary grid to assign values into
int row = 0; //variable for navigating 'rows'
int col = 0; //variable for navigating 'columns'
int newVal; //value to place into grid
bool solved;
List <int> valueSet = new List <int>(Enumerable.Range(-9, 9)); //range
//of numbers that can be added to the grid
List <int> valueSet2 = new List <int>(); //placeholder values in column 0
Random rnd = new Random(); //random variable for choosing random number
int randIndex = 0; //index in valueSet/valueSet2 that is accessed
randIndex = rnd.Next(0, 8); //get a random number and place in grid(0,0)
newVal = valueSet[randIndex];
tempGrid.InitSetCell(row, col, newVal);
valueSet.Remove(newVal); //remove paced value from options
for (row = 1; row < 9; row++)
{ //fills in column 0 with remaining possible values, storing in place-
//holder as it goes so as to preserve when placing in row 0 later
randIndex = rnd.Next(0, valueSet.Count);
newVal = valueSet[randIndex];
valueSet2.Add(newVal);
valueSet.Remove(newVal);
tempGrid.InitSetCell(row, col, newVal);
}
row = 0; //reset row to 0
for (col = 1; col < 3; col++)
{ //fills in col 1,2 of row 0, checking that don't duplicate the
//values in rows 1,2 of col 0
randIndex = rnd.Next(0, valueSet2.Count);
newVal = valueSet2[randIndex];
while ((newVal == tempGrid.Grid[1, 0] || (newVal == tempGrid.Grid[2, 0])))
{
randIndex = rnd.Next(0, valueSet2.Count);
newVal = valueSet2[randIndex];
}
valueSet2.Remove(newVal);
tempGrid.InitSetCell(row, col, newVal);
}
for (col = 3; col < 9; col++)
{ //fill in remainder of row 0 with remaining possible values
randIndex = rnd.Next(0, valueSet2.Count);
newVal = valueSet2[randIndex];
valueSet2.Remove(newVal);
tempGrid.InitSetCell(row, col, newVal);
}
do
{
puzzleSolver = new PuzzleSolver();
puzzleSolver.SolveGrid((PuzzleGrid)tempGrid.Clone(), false); //Slv to fill remainder of grid
SolutionGrid = puzzleSolver.SolutionGrid;
} while (SolutionGrid == null || SolutionGrid.IsBlank());
PermaGrid = Blanker(SolutionGrid); //call Blanker to carry out the
return(PermaGrid); //blanking of fileds,then return the grid to user to solve
}
// Call SolveGrid to solve puzzlegrid
//Store solved gamegrid as the correct solution in solutiongrid
public PuzzleGrid Blanker(PuzzleGrid solvedGrid)
{ //enable blanking of squares based on difficulty
PuzzleGrid tempGrid;
PuzzleGrid saveCopy;
//temporary grids to save between tests
bool unique = true; //flag for if blanked form has unique soln
int totalBlanks = 0; //count of current blanks
int tries = 0; //count of tries to blank appropriately
int desiredBlanks; //amount of blanks desired via difficulty
int symmetry = 0; //symmetry type
tempGrid = (PuzzleGrid)solvedGrid.Clone();
//cloned input grid (no damage)
Random rnd = new Random(); //allow for random number generation
switch (difficulty) //set desiredBlanks via chosen difficulty
{
case Difficulty.Easy: //easy difficulty
desiredBlanks = 40;
break;
case Difficulty.Medium: //medium difficulty
desiredBlanks = 45;
break;
case Difficulty.Hard: //hard difficulty
desiredBlanks = 50;
break;
default: //easy difficulty
desiredBlanks = 40;
break;
}
symmetry = rnd.Next(0, 2); //Randomly select symmetry
do
{ //call RandomlyBlank() to blank random squares symmetrically
saveCopy = (PuzzleGrid)tempGrid.Clone(); // in case undo needed
tempGrid = RandomlyBlank(tempGrid, symmetry, ref totalBlanks);
//blanks 1 or 2 squares according to symmetry chosen
puzzleSolver = new PuzzleSolver();
unique = puzzleSolver.SolveGrid((PuzzleGrid)tempGrid.Clone(), true); // will it solve uniquely?
if (!unique)
{
tempGrid = (PuzzleGrid)saveCopy.Clone();
tries++;
}
} while((totalBlanks < desiredBlanks) && (tries < 1000));
solvedGrid = tempGrid;
solvedGrid.Finish();
return(solvedGrid);
}
private void EntryCompleteClick(object sender, RoutedEventArgs e)
{
puzzleSolver = new PuzzleSolver();
var result = puzzleSolver.SolveGrid((PuzzleGrid)puzzleGrid.Clone(), true);
if (result == true)
{
LeavePuzzleEntryState();
}
else
{
MessageBox.Show("That puzzle is not solvable, please modify it so that it is.");
}
}
/// <summary>
/// This method shows the open file dialog box.
/// </summary>
private void OpenFile()
{
// Show save file dialog box
var result = openGameDialog.ShowDialog();
// Process save file dialog box results
if (result == true)
{
// Save document
string fileName = openGameDialog.FileName;
PuzzleGrid grid = fileHandler.OpenFile(fileName);
puzzleGrid = (PuzzleGrid)grid.Clone();
if (grid == null)
{
MessageBox.Show("There was a problem opening your file. Please try again.");
}
else
{
SetPuzzleGrid(grid);
}
}
}
/// <summary>
/// SolveGrid attempts to solve a puzzle by checking through all
/// possible values for each cell, discarding values that do not lead
/// to a valid solution. On a try, it recursively calls itself to
/// maintain previous states of the grid to back track to if the
/// current path fails. It creates a local version of the grid to
/// facilitate this. It also checks if the puzzle is uniquely solvable.
/// </summary>
/// <param name="g">Current state of the grid</param>
/// <param name="checkUnique">Do we care if it has unique soln?</param>
/// <returns></returns>
public bool SolveGrid(PuzzleGrid g, bool checkUnique)
{
PuzzleGrid grid = new PuzzleGrid();
grid = (PuzzleGrid)g.Clone(); //Copy the input grid
int i, choice, r, c, numChoices;
bool done, got_one, solved, result;
got_one = false;
recursions++;
FillSingleChoices(grid); //First, fill in all single choice values
if (IsSolved(grid)) //If it's already solved
{
if (numSolns > 0) //If another soln already found
{
stoplooking = true; //Don't look for more
result = false; //Return false, no UNIQUE soln
}
else //If no other soln found yet
{
numSolns++;
final[numSolns] = (PuzzleGrid)g.Clone(); //Save found soln
result = true;
SolutionGrid = grid;
}
}
else //If not solved yet
{
if (!FindFewestChoices(grid, out r, out c, out numChoices))
{
result = false; //Invalid solution
}
else //Current grid still valid
{
i = 1;
done = false;
got_one = false;
while (!done && i <= numChoices)
{
choice = PickOneTrue(); //Pick a possible value
list[choice] = false; //Won't want to use it again
grid.UserSetCell(r, c, choice);
if (recursions < MaxDepth)
{
//-----------We must go deeper. SUDCEPTION!-----------//
solved = (SolveGrid(grid, checkUnique)); //Recurse
}
else
{
solved = false;
}
if (stoplooking == true)
{
done = true;
got_one = true;
}
else
{
got_one = (got_one || solved);
if (!checkUnique) //If not looking for unique soln
{
done = got_one; //Then we have a solution
}
}
i++;
}
result = got_one;
}
}
return result;
}
