Le jeu de la vie est un jeu inventé en 1970 par John Conway (1937-2020 Grand mathématicien britannique).

Une grille est constituée de cases carrées. Chaque case est une cellule.

• Certaines cellules sont vivantes (ici les bleues),
• la grille évolue : certaines cellules meurent (deviennent blanches), et certaines naissent (deviennent bleues),
• le jeu défini des règles précises déterminant quelles cellules naissent et quelles cellules meurent.

On considère l'état de la grille à un instant donné.

• On commence par compter le nombre de voisines vivantes de chaque cellules. On compte parmi les 8 voisines immédiates (on compte les voisines en diagonale)
• Quand une cellule morte a 3 voisines vivantes, elle naît.
• Quand une cellule vivante a autre chose que 2 ou 3 voisines vivantes,elle meurt.

Ci-dessous, les cellules encadrée en rouge meurent et celles en vert naissent. Les autres ne changent pas.

Une fois que l'on a décidé quelles cellules allaient naître ou mourir, on réactualise la grille :

On peut utiliser Tkinter.

Voici les éléments dont vous pourriez avoir besoin :

from tkinter import * # bibliothèque graphique

# on convient de dimensions :
WIDTH = 80          # La grille de jeu a 80 cellules de large
HEIGHT = 60         # et 60 de haut
CELL_SIZE = 10      # chaque cellule fait 10 pixels de côté
LIFE_COLOR = 'blue' # cellule vivante est bleue
DEAD_COLOR = '#fff' # cellule morte est blanche

root = Tk()        # création de la fenêtre Tkinter
root.title("Life") # on attribue un titre à la fenêtre

# création de la zone de dessin - canvas
canvas = Canvas(root, width = WIDTH*CELL_SIZE, height = HEIGHT*CELL_SIZE, bd=0, bg="white")
canvas.pack() # insertion de la zone de dessin dans la fenêtre

La fenêtre graphique est vide. Le mieux est de créer des carrés qui resteront les mêmes tout du long de l'animation mais qui changeront de couleurs. Chaque carré représente une cellule pouvant être vivante ou morte.

def create_new_cell(line:int, col:int, coul:str):
    '''
    Crée une nouvelle cellule dans la zone de dessin,
    à la ligne line et colonne col, de couleur coul
    la fonction renvoie un identifiant de l'objet graphique créé
    '''
    x = col * CELL_SIZE
    y = line * CELL_SIZE
    return canvas.create_rectangle(x, y, x + CELL_SIZE, y + CELL_SIZE, fill=coul)

Lors de la création d'une cellule, on a pu récupérer un identifiant – c'est un entier – qu'il faut conserver car cet identifiant nous permettra d'atteindre la cellule et de demander son changement de couleur.

Dans la fonction, canvas est pris comme variable globale. C'est un choix légitime car il n'y aura jamais qu'une fenêtre graphique active dans notre programme. Si on trouve que ce n'est pas assez propre, on peut toujours ajouter le canvas en argument de la fonction.

def change_cell_coul(cell_id:int, new_coul:str):
    '''
    pour une cellule dont l'identifiant est fourni,
    on impose une nouvelle couleur
    '''
    canvas.itemconfig(cell_id, fill=new_coul)

Le jeu de la vie est plus intéressant s'il bouge un peu !

Tkinter permet un mécanisme de réactualisation de l'affichage. Pour cela on définit une fonction chargée de réactualiser l'affichage et qui est rappelée périodiquement, par exemple toutes les secondes.

Dans notre cas, la fonction de réactualisation doit se charger d'examiner la grille de jeu et de définir quelles cellules doivent naître (passer de morte à vivante) ou mourir.

def reactualisation():
    # à vous de faire...
    
    # pour que la réactualisation se relance 1s plus tard, la fonction se termine par :
    root.after(1000, reactualisation)

# et en fin de script, on amorce en programmant une première
# réactualisation
root.after(0, reactualisation)
# et on lance la boucle qui maintient l'affichage de la fenêtre
root.mainloop()

D'une part, nous devons stoker l'état de chaque cellule (vivante ou morte) et d'autre part, pour assurer l'affichage, nous devons stoker l'identifiant du carré représentant la cellule sur le canvas.

Nos cellules sont réparties sur une grille. On va stocker nos données dans un tableau. Nous avons deux approches possibles :

# tableau de tableaux, soit un tableau en 2D
# exemple pour l'information sur l'état :
vivantes = [ [False, False, False, ..., False],    # prévoir 80 colonnes comme indiqué plus haut
             [False, True,  False, ..., True ],
             ...
             [False, False, True,  ..., True ] ],  # et prévoir 60 lignes

# True pour une cellule vivante, False pour une morte
# pour atteindre la cellule de ligne 13 et colonne 5
vivantes[13][5]
# la cellule en haut à gauche est à la ligne 0 et colonne 0

Le choix de tableau 2D ci-dessus peut sembler s'imposer puisque la grille de jeu est elle-même en 2D. Mais il est parfois plus simple de passer par un tableau 1D :

# tableau 1D
# exemple pour l'information sur l'état :
vivantes = [ False, False, False, ..., False,    # prévoir 80 colonnes comme indiqué plus haut
             False, True,  False, ..., True ,
             ...
             False, False, True,  ..., True ],  # et prévoir 60 lignes

# Les cellules sont données tout à la suite ce qui fait qu'on a un tableau de HEIGHT*WIDTH items
# pour atteindre la cellule de ligne 13 et colonne 5
vivantes[13*WIDTH + 5]
# la cellule en haut à gauche est à la ligne 0 et colonne 0

À vous de choisir. À mon avis, la grille 1D vaut mieux.