/// <summary>
/// Removes fields from the full solution.
/// </summary>
/// <param name="level"></param>
private void SetupBoard(SudokuLevel level)
{
for (int i = 0; i < 9; i++)
{
board[i] = new int?[9];
for (int j = 0; j < 9; j++)
{
board[i][j] = solution[i][j];
}
}
int remainingItems = ((int)level + 1) * 20;
while (remainingItems > 0)
{
int posX = random.Next(9);
int posY = random.Next(9);
if (board[posX][posY] == null)
{
continue;
}
board[posX][posY] = null;
remainingItems--;
}
}
private int[,] GetNewSudoku(SudokuLevel level)
{
// Realiza la petición de un nuevo sudoku y espera a su recepción
// Intenté hacerlo con async/await pero no conseguí hacerlo funcionar
var request = client.GetAsync(string.Format(PARAMS, (int)level));
request.Wait();
var response = request.Result;
response.EnsureSuccessStatusCode();
var jsonStringAsync = response.Content.ReadAsStringAsync();
jsonStringAsync.Wait();
var jsonString = jsonStringAsync.Result;
var sudokuNumbers = JObject.Parse(jsonString)["squares"];
var numbers = new int[Tamaño, Tamaño];
foreach (var number in sudokuNumbers)
{
numbers[(int)number["y"], (int)number["x"]] = (int)number["value"];
remainingNumbers--;
}
return(numbers);
}
public ISudokuResult Solve(int[,] data)
{
var result = _solver.Solve(data);
result.Level = SudokuLevel.GetLevel(result);
return(result);
}
public void IsMaxLimitExceededTest_Negativee()
{
var sudokuLevel = new SudokuLevel(ESudokuLevel.Medium);
var sudokuResultMock = new Mock <ISudokuResult>();
Assert.IsFalse(sudokuLevel.IsMaxLimitExceeded(sudokuResultMock.Object));
}
public Sudoku(SudokuLevel level, Action SudokuLoaded)
{
CeldaCambiada += (fila, col, num) => { };
// Se crea el cliente HTTP si es necesario
if (client == null)
{
client = new HttpClient();
client.BaseAddress = new Uri(BASE_URI);
}
// Se solicita un nuevo sudoku al servicio en un nuevo hilo en segundo plano
var downloadTask = Task.Factory.StartNew(() =>
{
_números = GetNewSudoku(level);
});
// Cuando la tarea anterior finalice, se ejecuta el resto del código y se avisa MainWindow que el sudoku está listo
downloadTask.ContinueWith(new Action <Task>((t) =>
{
esInicial = new bool[Tamaño, Tamaño];
for (int f = 0; f < Tamaño; ++f)
{
for (int c = 0; c < Tamaño; ++c)
{
esInicial[f, c] = _números[f, c] > 0;
}
}
SudokuLoaded();
}), TaskScheduler.FromCurrentSynchronizationContext());
}
/// <summary>
/// Очистка случайных ячеек.
/// Количество очищаемых ячеек взято Level*10 (при пяти уровнях это кажется нормальным)
/// </summary>
private void ClearCells(ref byte[,] grid)
{
// Уровень сложности игры
int delete10 = (int)GameLevel;
if (delete10 > 7)
{
// Не хотим допустить, чтобы судоку каким-то образом представляло собой пустое поле
GameLevel = SudokuLevel.простейший;
}
// Очистка случайной ячейки из всего набора
int index, x, y;
for (int i = 0; i < delete10 * 10; i++)
{
// Выбор случайной не пустой ячейки
do
{
index = random.Next(81);
x = index / 9;
y = index % 9;
}while (grid[x, y] == 0);
// Очистка ячейки
grid[x, y] = 0;
}
}
private void RadioButton_Checked(object sender, RoutedEventArgs e)
{
level = RB_Easy.IsChecked == true ?
SudokuLevel.EASY :
RB_Med.IsChecked == true ?
SudokuLevel.MEDIUM :
SudokuLevel.HARD;
}
public void IsMaxLimitExceededTest_Positive()
{
var sudokuLevel = new SudokuLevel(ESudokuLevel.Medium);
var sudokuResultMock = new Mock <ISudokuResult>();
sudokuResultMock.SetupGet(r => r.BackTrackCount).Returns(1000);
Assert.IsTrue(sudokuLevel.IsMaxLimitExceeded(sudokuResultMock.Object));
}
public void IsMatchingTest_Negative_NotEnoughLevel()
{
var sudokuLevel = new SudokuLevel(ESudokuLevel.Medium);
var sudokuResultMock = new Mock <ISudokuResult>();
sudokuResultMock.SetupGet(r => r.HasUniqueSolution).Returns(true);
Assert.IsFalse(sudokuLevel.IsMatching(sudokuResultMock.Object));
}
/// <summary>
/// Обработка выбора одного из уровней сложности игры
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RadioButton_Click(object sender, EventArgs e)
{
// Сохранение выбора
Level = (SudokuLevel)(((RadioButton)sender).Tag);
// Закрытие формы выбора с возвратом положительного решения
DialogResult = DialogResult.OK;
}
public void IsMatchingTest_Positive()
{
var sudokuLevel = new SudokuLevel(ESudokuLevel.Medium);
var sudokuResultMock = new Mock <ISudokuResult>();
sudokuResultMock.SetupGet(r => r.HasUniqueSolution).Returns(true);
sudokuResultMock.SetupGet(r => r.BackTrackCount).Returns(200);
Assert.IsTrue(sudokuLevel.IsMatching(sudokuResultMock.Object));
}
public void GenerateTest()
{
var solver = new ClassicSudokuSolver(EClassicSudokuType.Classic9x9);
var generator = new ClassicSudokuGenerator(solver);
var level = new SudokuLevel(ESudokuLevel.Medium);
var data = generator.Generate(level);
var resultOfSolvingGeneratedSudoku = solver.Solve(data.Data);
Assert.IsTrue(resultOfSolvingGeneratedSudoku.HasUniqueSolution);
}
/// <summary>
/// Посылка сообщения на WebSocket-сервер с запросом на начало новой игры
/// </summary>
/// <param name="level">Выбранный игроком уровень сложности</param>
/// <param name="playerName">Имя игрока</param>
public async void NewGameAsync(SudokuLevel level, string playerName)
{
GameLevel = level;
inGame = true;
await SendMessage(new SocketMessage
{
messageType = MessageType.StartGame,
level = GameLevel,
text = playerName,
});
}
/// <summary>
/// Посылка на WebSocket-сервер сообщения о том, что игрок не хочет играть в игру с имеющимся уровнем сложности, а значит и принимать дальнейшего участия в текущей игре
/// </summary>
/// <param name="playerLevel">Уровень сложности, выбранный игроком</param>
public async void PlayerOutOfGame(SudokuLevel playerLevel)
{
// Установка соответствующего флага
inGame = false;
// Отказ от получения сообщений
await SendMessage(new SocketMessage
{
messageType = MessageType.OutOfGame,
level = playerLevel,
});
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="level">Уровень сложности игры</param>
public GameSudoku(SudokuLevel level)
{
/// <summary>
/// Таблица для создания условия новой игры.
/// Начальное значение всегда одинаково, оно меняется в методах Shuffle и ClearCells, и таким образом получается условие очередной игры.
/// </summary>
byte[,] grid =
{
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 }, // +
{ 4, 5, 6, 7, 8, 9, 1, 2, 3 }, // | первый горизонтальный регион
{ 7, 8, 9, 1, 2, 3, 4, 5, 6 }, // _
{ 2, 3, 4, 5, 6, 7, 8, 9, 1 }, // +
{ 5, 6, 7, 8, 9, 1, 2, 3, 4 }, // | второй горизонтальный регион
{ 8, 9, 1, 2, 3, 4, 5, 6, 7 }, // _
{ 3, 4, 5, 6, 7, 8, 9, 1, 2 }, // +
{ 6, 7, 8, 9, 1, 2, 3, 4, 5 }, // | третий горизонтальный регион
{ 9, 1, 2, 3, 4, 5, 6, 7, 8 } // _
// | | | |___|- третий вертикальный регион
// | |___|- второй вертикальный регион
//___|- первый вертикальный регион
};
// Сохранение уровня сложности игры
GameLevel = level;
// Задание начального значения для счётчика псевдослучайных чисел
random = new Random(DateTime.Now.Hour * DateTime.Now.Minute * DateTime.Now.Second);
// Перемешивание начальной таблицы
Shuffle(ref grid);
// Очистка случайных ячеек в зависимости от уровня: чем он меньше, тем меньше клеток очищаем
ClearCells(ref grid);
// Перенос сформированного условия из массива байтов в ячейки игры
FillSudokuCells(grid);
}
public void GenerateSudoku(SudokuLevel level)
{
GenerateSolution();
SetupBoard(level);
}
