 |
Sommaire
|
|
|
|
|
|
 Génération et résolution |
|
|
|
|
|
|
Il nous faut maintenant visualiser les grandes lignes du Sudoku en termes informatiques. Le première chose à faire est de trouver comment représenter, et stocker, la grille de chiffres, de telle sorte que l'on puisse facilement accéder à chaque case. La réponse vient rapidement, sous la forme d'un tableau imbriqué que l'on pourra parcourir à l'aide de boucles for() imbriquées.
Notre objectif n'est pas ici de disposer d'une série de grilles préremplies, car le joueur se lasserait vite. Il nous faut donc remplir notre grille de manière aléatoire, afin d'assurer l'unicité de celle-ci - et donc le renouvellement du jeu. Les techniques de génération de grille sont nombreuses et répondent à certains critères établis, parmi lesquels l'aspect symétrique de la grille de jeu. Les algorithmes pour générer une telle grille tout en respectant les contraintes du jeu sont assez complexes, aussi pour notre approche nous allons partir d'une grille valide très simple, et mélanger ses éléments en prenant garde de ne pas lui faire perde sa validité, sans se soucier de la symétrie pour le moment.
Notre grille de départ sera donc toujours la même, créée à la main sans chercher à la compliquer dès le départ, mais simplement en faisant un décalage d'une ligne à l'autre et d'une région à l'autre, et en remplissant chaque chiffre linéairement.
Ce faisant, il nous faut mélanger les chiffres de telle sorte que l'on n'y verra plus la linéarité. Notre grille étant déjà valide, une solution accessible consiste à intervertir les chiffres, au hasard : le 1 remplace le 8 et le 8 remplace le 1, le 5 remplace le 4 et vice-versa... Aussi souvent qu'on le souhaite.
 |
|
Exemple du contenu de notre tableau de booléen :
les cases contenant true ne seront pas effacée ni modifiables.
|
Il nous faut également déterminer quelles cases de la grille conserveront leurs chiffres, et quelles cases seront effacées. Dans les faits, cela suppose de savoir combien de cases seront enlevées à chaque ligne : plus il y a de cases enlevées, plus le jeu sera difficile à résoudre - ce qui nous permet d'introduire jusqu'à 8 niveaux de difficulté, selon le nombre de cases que l'on souhaite enlever.
Nous n'aurons donc pas un tableau imbriqué, mais trois : le tableau original, qui une fois généré et mélangé sera copié dans un second tableau qui servira de solution, et un troisième tableau que l'on aura rempli de booléens indiquant quelles cases sont vidées, et qui servira à effacer le contenu du tableau original avant de l'afficher à l'écran.
Reste à savoir comment déterminer si les chiffres entrés par l'utilisateur sont les bons. Nous nous sommes ici encore simplifié la tâche : notre jeu n'indiquera pas qu'un chiffre entré par le joueur existe déjà dans la ligne, la colonne ou la région de la case, mais implémente à la place une comparaison avec le tableau de solution, et un test final qui vérifie que l'ensemble de la grille est correctement rempli.
Ce test final part d'un principe simple : si chaque ligne est correctement remplie, alors l'addition de tous ses chiffres (1+2+3+4+5...) donnera 45. Si toutes les lignes donnent 45 lors de l'addition de leurs cases respectives, alors le joueur les a toutes correctement remplies. Ce test ne vient que corroborer la validation donnée au fil de l'eau par la comparaison avec la solution.
|
