public bool AppliesAt(int x, int y, SudokuGrid grid)
{
if (house == Houses.Cell)
{
return(x == i0 && y == i1);
}
if (house == Houses.Column)
{
return(x == i0);
}
if (house == Houses.Row)
{
return(y == i0);
}
if (house == Houses.Box)
{
return(grid.BoxAt(x, y) == i0);
}
if (house == Houses.MajorDiagonal)
{
return(x == y);
}
if (house == Houses.MinorDiagonal)
{
return(x == grid.Cells - y - 1);
}
if (house == Houses.Cage)
{
return(grid.CageAt(x, y) == i0);
}
return(false);
}
public SolveResult DoLogicalSolve(SudokuGrid grid, HintSelections hs)
{
if (hs == null)
{
return(DoBacktrackingSolve(grid));
}
while (true)
{
if (Solved)
{
return(SolveResult.SingleSolution);
}
Hint hint = SingleHint(hs);
if (hint == null)
{
return(SolveResult.TooDifficult);
}
SolveResult result = hint.Apply(grid);
if (result != SolveResult.Ongoing)
{
return(result);
}
}
}
private void InitCells(SudokuGrid grid)
{
CurrentCell = new SudokuCell(FirstCellRowPosition, FirstCellColPosition);
CurrentCellRowIndex = 0;
CurrentCellColIndex = 0;
const int SudokuDim = SudokuGrid.SudokuDimension;
cells = new SudokuCell[SudokuDim, SudokuDim];
int currWindowRowPos = GameWindow.FirstCellRowPosition;
int currWindowColPos = GameWindow.FirstCellColPosition;
const int RowIncrement = GameWindow.CellPositionRowIncrements;
const int ColIncrement = GameWindow.CellPositionColIncrements;
for (int row = 0; row < SudokuDim; row++)
{
for (int col = 0; col < SudokuDim; col++)
{
cells[row, col] = new SudokuCell(grid[row, col], grid.IsEditable(row, col), currWindowRowPos, currWindowColPos);
currWindowColPos += ColIncrement;
}
currWindowColPos = GameWindow.FirstCellColPosition;
currWindowRowPos += RowIncrement;
}
menuCells = new MenuCell[MenuItemLabels.Length];
for (int item = 0; item < menuCells.Length; item++)
{
menuCells[item] = new MenuCell(MenuItemsCellRowPosition, MenuItemsCellColPositions[item], MenuItemLabels[item]);
}
RedrawCells();
}
public void FillTemplate(XmlDocument doc, SudokuGrid grid)
{
XmlNode sudoku = doc.CreateNode(XmlNodeType.Element, "Sudoku", "");
XmlNode hints = doc.CreateNode(XmlNodeType.Element, "Hints", "");
XmlNode rows = doc.CreateNode(XmlNodeType.Element, "Rows", "");
doc.AppendChild(sudoku);
sudoku.AppendChild(hints);
hints.AppendChild(rows);
for (int row = 0; row < 9; row++)
{
XmlNode node = doc.CreateNode(XmlNodeType.Element, "Row", "");
rows.AppendChild(node);
for (int col = 0; col < 9; col++)
{
if (grid[row, col] == 0)
{
node.InnerText += "-,";
}
else
{
node.InnerText += grid[row, col] + ",";
}
}
if (node.InnerText.Length > 0)
{
node.InnerText = node.InnerText.Remove(node.InnerText.Length - 1, 1);
}
}
}
void UpdateTooltip(int x, int y, SudokuGrid grid)
{
StringBuilder hints = new StringBuilder();
foreach (Hint hint in Grid.PaintedHints)
{
if (AppliesAt(hint, x, y, grid))
{
hints.AppendLine(hint.ToString());
}
}
if (hints.Length == 0)
{
if (toolTipText != null)
{
toolTipText = null;
toolTip1.Active = false;
}
}
else
{
if (toolTipText == null ||
!toolTipText.Equals(hints.ToString()))
{
toolTipText = hints.ToString();
toolTip1.Active = true;
toolTip1.SetToolTip(this, toolTipText);
}
}
}
public SudokuZone(SudokuGrid grid, int row, int col)
{
InitializeComponent();
this._grid = grid;
this._cells = new SudokuCell[grid.Puzzle.Rank, grid.Puzzle.Rank];
this._row = row;
this._column = col;
StackPanel zoneStackPanel = new StackPanel() { Orientation = Orientation.Vertical };
for (int i = 0; i < grid.Puzzle.Rank; i++)
{
StackPanel rowStackPanel = new StackPanel() { Orientation = Orientation.Horizontal };
for (int j = 0; j < grid.Puzzle.Rank; j++)
{
SudokuCell cell = new SudokuCell(this, i, j);
this._cells[i, j] = cell;
rowStackPanel.Children.Add(cell);
}
zoneStackPanel.Children.Add(rowStackPanel);
}
this.SudokuCellContainer.Child = zoneStackPanel;
}
public SudokuZone()
{
InitializeComponent();
this._grid = null;
this._cells = new SudokuCell[3, 3];
this._row = 0;
this._column = 0;
StackPanel zoneStackPanel = new StackPanel() { Orientation = Orientation.Vertical };
for (int i = 0; i < 3; i++)
{
StackPanel rowStackPanel = new StackPanel() { Orientation = Orientation.Horizontal };
for (int j = 0; j < 3; j++)
{
SudokuCell cell = new SudokuCell();
this._cells[i, j] = cell;
rowStackPanel.Children.Add(cell);
}
zoneStackPanel.Children.Add(rowStackPanel);
}
this.SudokuCellContainer.Child = zoneStackPanel;
}
public static SudokuGrid Random()
{
SudokuGrid newGrid = new SudokuGrid();
Dictionary <int, List <int> > columnValues = new Dictionary <int, List <int> >();
Dictionary <int, List <int> > boxValues = new Dictionary <int, List <int> >();
for (int i = 0; i < 9; i++)
{
columnValues[i] = new List <int>();
boxValues[i] = new List <int>();
}
for (int i = 0; i < 9; i++)
{
var rowValues = AssignRow(columnValues, boxValues, i);
for (int j = 0; j < 9; j++)
{
newGrid._grid[i, j] = rowValues[j];
columnValues[j].Add(rowValues[j]);
boxValues[GetBoxNumber(i, j)].Add(rowValues[j]);
}
}
return(newGrid);
}
public void FillDocument(XmlDocument doc, SudokuGrid grid, int CM)
{
XmlNode rows1 = doc.CreateNode(XmlNodeType.Element, "Rows", "");
XmlNode rows2 = doc.CreateNode(XmlNodeType.Element, "Rows", "");
XmlNode sudoku = doc.CreateNode(XmlNodeType.Element, "Sudoku", "");
XmlNode hints = doc.CreateNode(XmlNodeType.Element, "Hints", "");
XmlNode guesses = doc.CreateNode(XmlNodeType.Element, "Guesses", "");
doc.AppendChild(sudoku);
sudoku.AppendChild(hints);
sudoku.AppendChild(guesses);
guesses.AppendChild(rows1);
hints.AppendChild(rows2);
for (int row = 0; row < 10; row++)
{
XmlNode node = doc.CreateNode(XmlNodeType.Element, "Row", "");
XmlNode node2 = doc.CreateNode(XmlNodeType.Element, "Row", "");
rows1.AppendChild(node2);
rows2.AppendChild(node);
if (row == 9)
{
node2.InnerText += CM.ToString();
}
else
{
for (int col = 0; col < 9; col++)
{
if (grid[row, col] == 0)
{
node.InnerText += "-,";
node2.InnerText += "-,";
}
else
{
if (grid.IsKnownElement(row, col))
{
node.InnerText += grid[row, col] + ",";
node2.InnerText += "-,";
}
else
{
node.InnerText += "-,";
node2.InnerText += grid[row, col] + ",";
}
}
}
if (node.InnerText.Length > 0)
{
node.InnerText = node.InnerText.Remove(node.InnerText.Length - 1, 1);
}
if (node2.InnerText.Length > 0)
{
node2.InnerText = node2.InnerText.Remove(node2.InnerText.Length - 1, 1);
}
}
}
}
//Generates and returns a new Sudoku grid
public static SudokuGrid Generate(SudokuGrid.Difficulty difficulty)
{
SudokuGrid generatedGrid = new SudokuGrid(ReadySudokus[randGenerator.Next(0, ReadySudokus.Length - 1)], difficulty, false);
//Do some transformations.
for (int transposeCount = 0; transposeCount < TransposeLimit; transposeCount++)
{
for (int groupSwapCount = 0; groupSwapCount < GroupSwapsLimit; groupSwapCount++)
{
for (int rowSwapCount = 0; rowSwapCount < RowSwapsLimit; rowSwapCount++)
{
generatedGrid.Transform(SudokuGrid.TransformType.SwapRows);
}
generatedGrid.Transform(SudokuGrid.TransformType.SwapGroups);
}
generatedGrid.Transform(SudokuGrid.TransformType.Transpose);
}
#region Remove some numbers.
int cellsToRemove = 0, emptyRowsLimit = 0;
switch (difficulty)
{
case SudokuGrid.Difficulty.Easy:
cellsToRemove = EasyDifficultyInitEmptyCells;
emptyRowsLimit = EasyDifficultyMaxEmptyRows;
break;
case SudokuGrid.Difficulty.Medium:
cellsToRemove = MediumDifficultyInitEmptyCells;
emptyRowsLimit = MediumDifficultyMaxEmptyRows;
break;
case SudokuGrid.Difficulty.Hard:
cellsToRemove = HardDifficultyInitEmptyCells;
emptyRowsLimit = HardDifficultyMaxEmptyRows;
break;
}
generatedGrid.EmptyCells = cellsToRemove;
//Start removing random numbers
int cellsRemoved = 0;
int rowsRemoved = 0;
int row, col;
const int IndexLimit = SudokuGrid.SudokuDimension - 1;
while (cellsRemoved <= cellsToRemove)
{
row = randGenerator.Next(0, IndexLimit);
col = randGenerator.Next(0, IndexLimit);
if (!(generatedGrid.IsSingleInRow(row, col) && rowsRemoved > emptyRowsLimit))
{
generatedGrid.ClearCell(row, col);
cellsRemoved++;
}
}
#endregion
return generatedGrid;
}
public static SudokuGrid Generate(SudokuGrid.Difficulty difficulty)
{
SudokuGrid generatedGrid = new SudokuGrid(ReadySudokus[randGenerator.Next(0, ReadySudokus.Length - 1)], difficulty, false);
for (int transposeCount = 0; transposeCount < TransposeLimit; transposeCount++)
{
for (int groupSwapCount = 0; groupSwapCount < GroupSwapsLimit; groupSwapCount++)
{
for (int rowSwapCount = 0; rowSwapCount < RowSwapsLimit; rowSwapCount++)
{
generatedGrid.Transform(SudokuGrid.TransformType.SwapRows);
}
generatedGrid.Transform(SudokuGrid.TransformType.SwapGroups);
}
generatedGrid.Transform(SudokuGrid.TransformType.Transpose);
}
#region Remove some numbers.
int cellsToRemove = 0, emptyRowsLimit = 0;
switch (difficulty)
{
case SudokuGrid.Difficulty.Easy:
cellsToRemove = EasyDifficultyInitEmptyCells;
emptyRowsLimit = EasyDifficultyMaxEmptyRows;
break;
case SudokuGrid.Difficulty.Medium:
cellsToRemove = MediumDifficultyInitEmptyCells;
emptyRowsLimit = MediumDifficultyMaxEmptyRows;
break;
case SudokuGrid.Difficulty.Hard:
cellsToRemove = HardDifficultyInitEmptyCells;
emptyRowsLimit = HardDifficultyMaxEmptyRows;
break;
}
generatedGrid.EmptyCells = cellsToRemove;
int cellsRemoved = 0;
int rowsRemoved = 0;
int row, col;
const int IndexLimit = SudokuGrid.SudokuDimension - 1;
while (cellsRemoved <= cellsToRemove)
{
row = randGenerator.Next(0, IndexLimit);
col = randGenerator.Next(0, IndexLimit);
if (!(generatedGrid.IsSingleInRow(row, col) && rowsRemoved > emptyRowsLimit))
{
generatedGrid.ClearCell(row, col);
cellsRemoved++;
}
}
#endregion
return(generatedGrid);
}
protected void CreateRequirements(SudokuGrid grid, int nc)
{
ca = new SudokuRequirement[nc];
for (int i = 0; i < ca.Length; ++i)
{
ca[i] = new SudokuRequirement();
}
}
public GameWindow()
{
grid = SudokuGenerator.Generate(SudokuGrid.Difficulty.Easy);
InitWindow();
InitCells(grid);
currentMenuItem = MenuItem.None;
currentMenuItemIndex = 0;
gameIsRunning = true;
}
public GameWindow()
{
grid = SudokuGenerator.Generate(SudokuGrid.Difficulty.Easy);
InitWindow();
InitCells(grid);
currentMenuItem = MenuItem.None;
currentMenuItemIndex = 0;
gameIsRunning = true;
}
public PaintContext(Graphics graphics, Size size, SudokuGrid grid, int selx, int sely)
: base(size, grid.CellA, grid.CellB)
{
this.grid = grid;
this.graphics = graphics;
this.selx = selx;
this.sely = sely;
SmallFont = new Font(FontFamily.GenericSansSerif, 10.0f);
LargeFont = new Font(FontFamily.GenericSansSerif, 30.0f);
}
protected void CreateOptionals(SudokuGrid grid, int nc)
{
co = new CageOptional[nc, Cells];
for (int i0 = 0; i0 < nc; ++i0)
{
for (int i1 = 0; i1 < Cells; ++i1)
{
co[i0, i1] = new CageOptional(grid.cageInfo);
}
}
}
public SudokuForm(SudokuGrid grid)
{
System.Diagnostics.Debug.Assert(Instance == null);
Instance = this;
InitializeComponent();
sudokuControl.Grid = grid;
CreateChildMenus();
UpdateMode();
LoadOptions();
}
private void easyButton_Click(object sender, EventArgs e)
{
// Seleccionamos el sudoku a mostrar
Random rnd = new Random();
int puzzlePick = rnd.Next(1, numOfSolvedGrids() + 1);
SudokuGrid sudokuGrid = new SudokuGrid(getPuzzle(puzzlePick));
PlayWindow pw = new PlayWindow(gameControl, sudokuGrid, 0);
pw.FormClosed += (s, args) => Close();
Hide();
pw.Show();
}
//////////////////////////
public SudokuGame(SudokuGrid sg, SudokuGames sgs)
{
SudokuGrid = sg;
Parent = sgs;
Id = Guid.NewGuid();
Players = new List <Player>();
Actions = new List <Action>();
SendClientsDelegate = SendClients;
Parent.Add(this);
}
private void NewGame(SudokuGrid.Difficulty difficulty)
{
grid = SudokuGenerator.Generate(difficulty);
for (int row = 0; row < 9; row++)
{
for (int col = 0; col < 9; col++)
{
cells[row, col].RefreshValues(grid[row, col], grid.IsEditable(row, col));
}
}
RefreshCellValues();
}
public void NewGame()
{
SudokuGrid = GameController.NewGame();
//Bind the cells
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
squares[i, j].DataContext = SudokuGrid[i, j];
}
}
}
public PlayWindow(GameControl gc, SudokuGrid sg, int difficulty) // difficulty: 0 - easy, 1 - medium, 2 - hard
{
InitializeComponent();
gameControl = gc;
gameControl.createButtonGrid(this, 40);
gameControl.setSizeOfWindow(this, 40);
gameControl.createToolbox(this, 50);
gameControl.setSelectedToolkitButtonName("toolkit1");
gameControl.setHighlightNumber(this, 1);
gameControl.showStartingNumbers(difficulty, sg);
gridDifficulty = difficulty;
sudokuGrid = sg;
initialToolkitCheck();
}
private void doWork(object state)
{
SudokuGrid sg = new SudokuGrid(path, file);
updateProgressLabel("Trabajando...");
sg.setUpPlacementOrders();
updateProgressBar();
for (int i = 0; i < 9; i++)
{
sg.doInitialPlacementFill(i);
}
updateProgressBar();
sg.populate(this);
}
public SudokuSolver(SudokuGrid grid)
{
Cells = grid.Cells;
CreateMatrix(grid);
for (int x = 0; x < Cells; ++x)
{
for (int y = 0; y < Cells; ++y)
{
if (grid.FlagAt(x, y) != SudokuGrid.CellFlags.Free)
{
TrySelectCandidate(GetCandidate(x, y, grid.ValueAt(x, y)));
}
}
}
}
public static void ReplaceListener(UpdateListener listener, SudokuGrid value, ref SudokuGrid grid)
{
if (grid == value)
{
return;
}
if (grid != null)
{
grid.RemoveListener(listener);
}
grid = value;
if (grid != null)
{
grid.AddListener(listener);
}
}
static void Main(string[] args)
{
SudokuGrid grid;
System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
s.Start();
grid = SudokuGrid.Random();
s.Stop();
Console.WriteLine(grid.ToString());
Console.WriteLine(s.ElapsedMilliseconds);
Console.ReadLine();
}
public TheGrid()
{
InitializeComponent();
SudokuGrid = GameController.CurrentGame;
// Cadrillage
for (int i = 0; i < 19; i += 2)
{
Rectangle rectCol = new Rectangle();
rectCol.SetValue(Grid.ColumnProperty, i);
rectCol.SetValue(Grid.RowSpanProperty, 19);
rectCol.Fill = new SolidColorBrush(Colors.Black);
sudokuGrid.Children.Insert(0, rectCol);
Rectangle rectRow = new Rectangle();
rectRow.SetValue(Grid.RowProperty, i);
rectRow.SetValue(Grid.ColumnSpanProperty, 19);
rectRow.Fill = new SolidColorBrush(Colors.Black);
sudokuGrid.Children.Insert(0, rectRow);
}
// Cases
squares = new Square[9, 9];
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
int gridCol = i * 2 + 1;
int gridRow = j * 2 + 1;
Square square = new Square();
square.SetValue(Grid.ColumnProperty, gridCol);
square.SetValue(Grid.RowProperty, gridRow);
sudokuGrid.Children.Add(square);
square.DataContext = SudokuGrid[i, j];
squares[i, j] = square;
square.Click += new RoutedEventHandler(square_Click);
}
}
}
static bool AppliesAt(Hint hint, int x, int y, SudokuGrid grid)
{
if (!(hint is ForcedMoveHint))
{
SudokuCandidate k = (SudokuCandidate)hint.Candidate;
if (k != null)
{
return(k.x == x && k.y == y);
}
}
SudokuRequirement c = (SudokuRequirement)hint.Requirement;
if (c != null)
{
return(c.AppliesAt(x, y, grid));
}
return(false);
}
public SudokuGrid Read(string filename)
{
try {
_xDoc.Load(filename);
SudokuGrid grid = new SudokuGrid(_xDoc);
return(grid);
} catch (Exception ex) {
System.Windows.Forms.MessageBox.Show("Couldn't Load the Grid in " + filename + "-->" + ex.ToString());
}
SudokuGrid Grid = new SudokuGrid();
for (int row = 0; row < 9; row++)
{
for (int col = 0; col < 9; col++)
{
Grid[row, col] = 0;
}
}
return(Grid);
}
public SolveResult DoBacktrackingProof(SudokuGrid grid, TextWriter log)
{
//verbose = false;
solnsFound = 0;
int osc = tsc;
BacktrackingProof(log);
if (solnsFound == 0)
{
return(SolveResult.NoSolutions);
}
if (solnsFound == 1)
{
for (int i = osc; i < sampleSoln.Length; ++i)
{
grid.SelectCandidate(sampleSoln[i]);
}
return(SolveResult.SingleSolution);
}
return(SolveResult.MultipleSolutions);
}
public void store_solution(Stack <DataNode> answer)
{
int[,] formatted_grid = new int[9, 9];
var rows = new List <int>();
foreach (var k in answer)
{
rows.Add(k.ID);
}
rows.Sort();
var grid = new List <int>();
foreach (var row in rows)
{
grid.Add(row % 9 + 1);
}
int x = 0;
int y = 0;
for (int i = 0; i < 81; i++)
{
formatted_grid[y, x] = grid[i];
x++;
if ((i + 1) % 9 == 0)
{
y++;
x = 0;
}
}
var sudoku = new SudokuGrid(formatted_grid);
if (sudoku.Valid)
{
Final_Solution = sudoku;
}
else
{
Console.WriteLine("Something went wrong -- solution found did not validate.");
}
}
public bool Move(Command move)
{
Player p = GetPlayer(move.Name);
if (p == null)
{
return(false);
}
int x = Convert.ToInt32(move.X);
int y = Convert.ToInt32(move.Y);
int value = Convert.ToInt32(move.Value);
if (!SudokuGrid.FillValue(x, y, value))
{
return(false);
}
AddAction(p, String.Format("move#{0}#{1}#{2}#{3}", p.Name, x, y, value));
if (SudokuGrid.IsFinish)
{
Locker.EnterWriteLock();
try
{
Parent.Remove(this);
}
finally
{
Locker.ExitWriteLock();
}
Command cmd = new Command(Parent, null, new string[] { "win", p.Name, this.Id.ToString() });
cmd.Execute();
AddAction(p, String.Format("win#{0}#{1}", p.Name, Id));
}
return(true);
}
public void solve_sudoku(SudokuGrid sudoku, string puzzle_name, string output_dir = "")
{
if (!sudoku.Valid)
{
throw new Exception(("Invalid Sudoku input."));
}
var watch = System.Diagnostics.Stopwatch.StartNew();
var dlx = new DLX(new ColumnNode(-1));
dlx.createLinkedList(sudoku.Grid);
var algX = new AlgorithmX(dlx.h);
algX.search();
watch.Stop();
SudokuGrid solution = algX.Final_Solution;
var elapsedMs = watch.ElapsedMilliseconds;
if (solution != null)
{
Console.WriteLine(string.Format("Puzzle \"{0}\" Solution:", puzzle_name));
solution.print_grid();
Console.WriteLine(string.Format("Puzzle \"{0}\" was solved in: {1} milliseconds", puzzle_name, elapsedMs));
if (!String.IsNullOrWhiteSpace(output_dir))
{
Directory.CreateDirectory(output_dir);
var filename = string.Format("{0}.sln.txt", puzzle_name);
string path = Path.Combine(output_dir, filename);
Console.WriteLine(String.Format("Your solved puzzle has been saved to the file: {0}", Path.GetFullPath(path)));
solution.Save_File(path);
}
}
else
{
Console.WriteLine("Something went wrong and your puzzle could not be solved. Press any key to exit...");
Console.ReadLine();
}
}
public Generator(SudokuGrid.GridOptions options)
{
grid = new SudokuGrid(options);
grid.Setup();
desc = options.isJigsaw ? "Jigsaw" : options.isKiller ? "Killer" : "Normal";
if (grid.MajorDiagonal && grid.MinorDiagonal)
{
desc += " Cross";
}
else if (grid.MajorDiagonal)
{
desc += " Major";
}
else if (grid.MinorDiagonal)
{
desc += " Minor";
}
desc += " " + options.Cells;
new Thread(new ThreadStart(AutoGenerate)).Start();
}
public void LoadBlankPuzzle(int rank)
{
SudokuGrid grid = new SudokuGrid(new SudokuPuzzle() { Rank = rank }, SudokuPuzzleLoadOptions.Blank) { HorizontalAlignment = System.Windows.HorizontalAlignment.Center };
this._currentPuzzleId = grid.Puzzle.Id;
this.PuzzlePreviewContainer.Child = grid;
}
public SudokuSolver(SudokuGrid grid)
{
this.grid = grid;
solutionFound = false;
}
private void InitCells(SudokuGrid grid)
{
//Initialize and set highlighted cell.
CurrentCell = new SudokuCell(FirstCellRowPosition, FirstCellColPosition);
CurrentCellRowIndex = 0;
CurrentCellColIndex = 0;
//Initialize other number fields.
const int SudokuDim = SudokuGrid.SudokuDimension;
cells = new SudokuCell[SudokuDim,SudokuDim];
int currWindowRowPos = GameWindow.FirstCellRowPosition;
int currWindowColPos = GameWindow.FirstCellColPosition;
const int RowIncrement = GameWindow.CellPositionRowIncrements;
const int ColIncrement = GameWindow.CellPositionColIncrements;
for (int row = 0; row < SudokuDim; row++)
{
for (int col = 0; col < SudokuDim; col++)
{
cells[row, col] = new SudokuCell(grid[row, col], grid.IsEditable(row, col), currWindowRowPos, currWindowColPos);
currWindowColPos += ColIncrement;
}
currWindowColPos = GameWindow.FirstCellColPosition;
currWindowRowPos += RowIncrement;
}
//Initialize menu items
menuCells = new MenuCell[MenuItemLabels.Length];
for (int item = 0; item < menuCells.Length; item++)
{
menuCells[item] = new MenuCell(MenuItemsCellRowPosition, MenuItemsCellColPositions[item], MenuItemLabels[item]);
}
RedrawCells();
}
public static bool Solve(SudokuGrid grid, out List<string> solution)
{
int[,] g = new int[(grid.Puzzle.Rank * grid.Puzzle.Rank), (grid.Puzzle.Rank * grid.Puzzle.Rank)];
for (int i = 0; i < (grid.Puzzle.Rank * grid.Puzzle.Rank); i++)
{
for (int j = 0; j < (grid.Puzzle.Rank * grid.Puzzle.Rank); j++)
{
g[i, j] = grid.GetCell(i, j).Value.HasValue ? grid.GetCell(i, j).Value.Value : 0;
}
}
bool result = Solve(g, grid.Puzzle.Rank, 0, 0);
if (result)
{
// Set the the solution
solution = new List<string>();
for (int i = 0; i < (grid.Puzzle.Rank * grid.Puzzle.Rank); i++)
{
string line = string.Empty;
for (int j = 0; j < (grid.Puzzle.Rank * grid.Puzzle.Rank); j++)
{
if (!string.IsNullOrEmpty(line))
{
line += ("," + g[i, j].ToString());
}
else
{
line += g[i, j].ToString();
}
}
solution.Add(line);
}
}
else
{
solution = grid.Puzzle.Format;
}
return result;
}
private void NewGame(SudokuGrid.Difficulty difficulty)
{
grid = SudokuGenerator.Generate(difficulty);
for (int row = 0; row < 9; row++)
{
for (int col = 0; col < 9; col++)
{
cells[row, col].RefreshValues(grid[row, col], grid.IsEditable(row, col));
}
}
RefreshCellValues();
}
public static bool Validate(int row, int col, int? value, SudokuGrid grid)
{
string message;
return SudokuDuplicateRule.Validate(row, col, value, grid, out message);
}
public static bool Validate(int row, int col, int? value, SudokuGrid grid, out string message)
{
if (value == null)
{
message = null;
return true;
}
if (grid.IsValueAvailable(row, col, value.Value))
{
message = null;
return true;
}
else
{
message = "Invalid input. Duplicate value present.";
return false;
}
}