Le jeu de Sudoku est un jeu de logique joué sur une grille de 9 * 9 cases, divisée en 9 blocs de 3 * 3 cases. Le but est de remplir chaque case avec un chiffre de 1 à 9, en respectant certaines règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc. Le jeu est terminé lorsque toutes les cases sont remplies ou lorsque toutes les vies ont été utilisées.

Logique du jeu

J’ai commencé par coder la couche logique du Sudoku. Pour stocker les informations, la grille est représentée par une matrice de 9 listes, contenant chacune 9 zéros.

board = reset()
def reset():
  return [[0 for i in range(9)] for j in range(9)]

Comme précédemment indiqué, le Sudoku doit respecter trois règles : chaque chiffre ne doit apparaître qu’une seule fois par ligne, colonne et bloc (un bloc étant un regroupement de 3 * 3 case). J’ai donc créé trois fonctions qui renvoient les éléments dans la ligne, la colonne et le bloc. Ensuite, j’ai créé une fonction qui appelle les trois précédentes et qui renvoie les nombres qui respectent les règles. Jusque-là, rien de bien compliqué.

def ligne(x):
  return [i for i in range(1,10) if i in board[x]]

def colonne(y):
  return [board[i][y] for i in range(9) if board[i][y] != 0]

def bloc(x, y):
  nums = []
  for i in range(x//3*3, x//3*3+3):
    for j in range(y//3*3, y//3*3+3):
      if board[i][j] != 0:
        nums.append(board[i][j])
  return nums

def possible(x, y):
  return [i for i in range(1,10) if i not in ligne(x)+colonne(y)+bloc(x,y)]

Il faut maintenant s’attaquer au plus complexe : créer la grille de Sudoku.

J’avais commencé par concevoir une grosse fonction qui créait bel et bien une grille valable de Sudoku, mais cette fonction était récursive (dans mon cas, elle s’appelait elle-même tant que la grille n’était pas valable). Et si sur ordinateur le jeu pouvait tourner (via un environnement de développement comme Thonny), ce n’était pas le cas sur Numworks où le nombre d’itération est très limitée.

Pour régler ce problème, j’avais modifié cette fonction qui faisait alors apparaître des nombres aléatoires présents dans la liste générée par possible(x, y). Par exemple, je générais un premier nombre, la grille étant vide tous les nombres étaient valides, puis un autre… jusqu’à une cinquantaine de nombres.

Mais je suis alors arrivé à un problème majeur : même si tous les nombres générés étaient valides, certains cases vides n’étaient pas solvables, c’est-à-dire que l’on ne pouvait placer aucun nombre car les seuls nombres pouvant être théoriquement placé étaient déjà présents dans la ligne/colonne/bloc par rapport à la case non solvable.

Je me suis retrouvé dans une impasse et c’est à ce moment-là que M. Robert m’a proposé un code qui parcourt la matrice à l’aide de deux boucles while. Pour chaque emplacement, le code vérifie si au moins un nombre peut être placé. Si c’est le cas, un nombre aléatoire est choisi dans le résultat de possible(x,y). Si aucun nombre n’est valide, la boucle recommence à la ligne précédente. Si le nombre d’essais dépasse 42, la fonction se bloque et recommence depuis le début.

def genere_board():
  global board
  board = reset()
  x = y = essai = 0
  while x!=9:
    essai += 1
    if essai ==42: 
      x = essai =0
      board = reset()
    y = 0
    while y!=9:
      if possible(x,y)==[]:
        board[x] = [0 for i in range(9)]
        y = 8
        x = x-1
      else:
        board[x][y] = choice(possible(x,y))
      y +=1
    x +=1
  return board

Maintenant que ma fonction principale est prête, je peux commencer à supprimer des nombres pour que la grille puisse être résolue. Cette fonction va donc prendre une case au hasard, et si elle est remplie, elle supprime le nombre.

def suppr():
  for i in range(40):
    x, y = randint(0,8), randint(0,8)
    while board[x][y] == 0:
      x, y = randint(0,8), randint(0,8)
    board[x][y] = 0

Gestion graphique (affichage)

Tout d’abord, j’ai généré une grille de 9 * 9, mais pour chaque bloc (groupe de 3 * 3 cases), la couleur change. Voici donc les deux fonctions qui s’en occupent :

def couleur(x,y,p=0):
  if (x//3 + y//3) %2 == 1:
    return (180-42*p,140-35*p,225)
  else:
    return (255,200-30*p,125-85*p)
    
def grille():
   for x in range(9):
    for y in range(9):
      rect(2+x*(22), 2+y*(22), 20, 20, couleur(x,y,0))

La fonction grille() ne dessine donc que la grille, mais elle utilise la fonction couleur(x, y, p) pour attribuer une couleur à chaque bloc. Grâce à l’opérateur modulo, on peut savoir dans bloc la case que l’on souhaite dessiner se trouve, et donc lui assigner la bonne couleur (en jaune ou en violet).

Résultat:

Ensuite, je me suis occupée du déplacement sur la grille. J’ai donc utilisé un exemple fourni par les professeurs que j’ai adapté :

def wait(buttons=(0,1,2,3,4,52)): 
  while True:
    for i in buttons:
      if keydown(i):
        while keydown(i): True 
        return i
 
while True:
  key_pressed = wait()
  pos_old = list(pos) 
  if key_pressed == 1:  # flèche haut
    pos[1] = (pos[1]-1) % pmax[1]
  elif key_pressed == 2: # flèche bas
    pos[1] = (pos[1]+1) % pmax[1]
  elif key_pressed == 3: # flèche droite
     pos[0] = (pos[0]+1) % pmax[0]
  elif key_pressed == 0: # flèche gauche
    pos[0] = (pos[0]-1) % pmax[0]
  if key_pressed not in (42, 43, 44, 36, 37, 38, 30, 31, 32):
    deplacement()

La fonction wait() attend qu’une touche soit pressée, et grâce au module ion, elle retourne la clé (valeur numérique identifiant la touche) de celle-ci qui est enregistrée dans key_pressed. Ensuite, en fonction de la touche pressée, la position via la variable pos change. L’opérateur modulo permet d’éviter de dépasser les limites de la grille. Il permet de retourner au début d’une ligne ou colonne lorsqu’on a atteint la fin de celle-ci.

Afin de repérer la case sur laquelle on se situe, j’ai ajouté la fonction surbrillance(), appelée par la fonction deplacement():

def surbrillance(x, y, mode):
  for i in range(9):
    rect(2+i*(22), 2+y*(22), 20, 20, couleur(i, y, mode))
    rect(2+x*(22), 2+i*(22), 20, 20, couleur(x, i, mode))
    if board[i][y] != 0:
      dessine_nb(i, y, board[i][y], mode)
    if board[x][i] != 0:
      dessine_nb(x, i, board[x][i], mode)
  for i in range(x//3*3, x//3*3+3):
    for j in range(y//3*3, y//3*3+3):
      rect(2+i*(22), 2+j*(22), 20, 20, couleur(i, j, mode))
      if board[i][j] != 0:
        dessine_nb(i, j, board[i][j], mode)
        
def deplacement():
  x, y = pos_old
  surbrillance(x,y,0)
  x, y = pos 
  surbrillance(x,y,1)
  rect(2+x*(20+2), 2+y*(20+2), 20, 20,couleur(x,y,2))
  if board[x][y]!=0:
    dessine_nb(x,y,board[x][y],2)

surbrillance() va redessiner les cases de la ligne, la colonne et le bloc associés à la case, en utilisant la couleur, fournit par couleur(x, y, mode).

La fonction deplacement() va donc à chaque fois qu’elle sera exécutée :

• Appeler surbrillance() en utilisant en paramètre les coordonnées de l’ancienne position et mode=0 ce qui va donc effacer la surbrillance précédente,
• Rappeler la fonction avec les nouvelles positions, et mode=1 ce qui va dessiner la nouvelle surbrillance.

Résulat:

J’ai ensuite rajouté la détections des touches du pavé numérique de la calculatrice. Pour faire cela, j’ai précisé dans la fonction wait() pour le paramètre buttons les clés 42, 43, 44, 36, 37, 38, 30, 31 et 32 qui correspondent respectivement aux touches 1, 2, 3, 4, 5, 6, 7, 8 et 9.

Une fois cela fait, j’ai indiqué dans le while vu précédemment – celui qui gère changements de la variables pos (… Mais si, je parle du while qui s’occupe des déplacements) – pour chaque nombre l’exécution de la fonction is_valid() en prenant comme en paramètre la position de la case (x et y) et le nombre qui veut être rajouté, dépendant donc de la touche que l’on presse.

elif  key_pressed == 42: #1
    is_valid(pos[0],pos[1],1)

Ici, si la touche 1 est pressée (qui correspond a la clé 42), la fonction is_valid() est appelée avec comme paramètre nb qui vaut 1.

def is_valid(x,y,nb):
  if board[x][y]==0:
    if nb == solution[x][y]:
      dessine_nb(x,y,nb,1)
      board[x][y]=nb

def dessine_nb(x,y,nb,mode):
  txt(str(nb),x*22+7,y*22+3,"black",couleur(x,y,mode))

La fonction is_valid() vérifie donc que le nombre indiqué en paramètre peut être placé, et si c’est le cas, il sera ajouté dans la matrice et dessiné dans la case sélectionnée (celle dont les positions sont indiqués en paramètre).

Autres fonctionnalités

Maintenant que la base du jeu est prête, on peut rajouter d’autres fonctionnalités. On va rajouter un système de difficulté et un système d’aide, que l’on pourra paramétrer via un menu. On va également rajouter un système de vie, pour que le jeu soit plus intéressant.

Je montrerai uniquement le principe pour la gestion des niveaux de difficulté, mais l’idée est la même pour le paramétrage de l’aide :

def draw_level(s=0):
  txt("Find", 237,35,(42+106*s,42+71*s,42+180*s))
  txt("< "*s+ "  "*(s==0) + str(lvl)+ " >"*s + "  "*(s==0), 225, 50,(42,)*3)
  
draw_level(1)
options = [32, 42, 52, 62]
diff = None
pos = 0

def select_diff():
  txt(str(options[pos]), 246, 50,(42,)*3)
  
while diff is None:
  key_pressed= wait()
  if key_pressed == 3: # fleche droite
    pos = (pos + 1) % len(options)
    select_diff()
  elif key_pressed == 0: # fleche gauche
    pos = (pos - 1) % len(options)
    select_diff()
  elif key_pressed in (4,52): # OK
    lvl= options[pos]
    break

Premièrement draw_level() permet de dessiner l’affichage du menu, si s=1 alors Find est en violet et les flèches apparaissent, sinon Find est en noir et les flèches ne s’affichent pas. Cette fonction va être appelée plusieurs fois afin de changer l’apparence de la sélection.

Dans la liste options est stockée les 4 difficultés. L’utilisateur peut alterner entre les 4 valeurs de la liste via les flèches gauche et droite grâce à la boucle et la condition while diff is None. Lorsque le joueur appuiera sur la touche OK, il confirmera sa sélection et quittera la boucle, afin de continuer la suite des instructions du programme. C’est en effet le même principe que la boucle pour gérer les déplacements.

Par la suite, la fonction suppr(lvl) est appelée (expliqué précedamment). Ainsi, le nombre de chiffre retiré de la matrice (la grille en somme) dépend du choix du joueur parmi les 4 proposés.

Comme je l’ai dit, l’idée est la même pour le choix de l’aide, sauf qu’au lieu d’avoir 4 choix, il n’y en a que deux : « On » ou « Off ».

Si « On » est sélectionnée, « Valid Number » apparait en bas à droite, et pour chaque déplacement dans la grille, aide() est appelée :

def aide(x,y):
  rect(200,155 ,200,20,(255,)*3)
  nbs = possible(x, y)  
  if board[x][y]==0:
    for i in range(len(nbs)):
      txt(str(nbs[i]), 265 + i * 20- len(nbs) *10, 155,(42,)*3)
      if nbs[i]!=nbs[-1]:
        txt(",", 275+ i * 20 - len(nbs) *10, 155,(42,)*3)
  else:
    txt("Full", 240,155)

Si la case sélectionnée est pleine, elle affiche « Full », sinon elle affiche tous les nombres qui pourrait être valables dans une case, générés par possible(x, y) vu précédemment.

On a presque mis en place toutes les fonctionnalités supplémentaires mais il manque encore une gameover quand le jeu se termine et le système de vie :

def check():
  c=0
  for i in range (9):
    for j in range (9):
      if board[i][j]!=0:
        c+=1
  return c==81

def coeur():
  rect(x+3,y+0,3,3, col)
  rect(x+15,y+0,3,3,col)
  rect(x+0,y+3,9,3,col)
  rect(x+12,y+3,9,3,col)
  rect(x+0,y+6,21,3,col)
  rect(x+3,y+9,15,3,col)
  rect(x+6,y+12,9,3,col)
  rect(x+9,y+15,3,3,col)
  
def perdre_vie():
    rect(272 - vie *25, 5, 21, 21, (255,) * 3)

La fonction perdre_vie() est appelée dans is_valid(). Si le nombre n’est pas juste, on retire une vie en décrémentant la variable vie de 1 et la fonction perdre_vie() est appelée. Elle dessine un carré blanc, afin d’effacer un des trois cœurs, dessiné au lancement du jeu avec coeur(222,5), coeur(247,5) et coeur(272,5).

La fonction check() regarde si la grille est remplie entièrement. Cette fonction est appelée à chaque déplacement dans la boucle principale while True :

while True:
  if vie==0:
    txt("Perdu!",230,5,(42,)*3,(255,)*3)
    break
  if check()==True :
    txt("  Gagné!  ",210,5,(42,)*3,(255,)*3)
    break

Ainsi si check() == True, le texte  » Gagné!  » apparait et la partie se termine grâce au break. Si le jeu se termine parce que l’utilisateur n’a plus de vie, c’est plutôt le texte « Perdu! » qui apparait.

Captures d’écran finale

Conclusion

Le jeu est donc fini ! La conception m’a pris relativement beaucoup de temps, mais ca m’a permit d’apprendre plein de chose ainsi que de m’améliorer en Python !

Si vous souhaitez le télécharger, voici le lien vers le script avec en supplément un lien vers la page de présentation du jeu :

Ilana R.

Étudiante en spécialité NSI en classe de 1ère en 2022.