Jeu de la vie

Introduction

Le jeu de la vie est un automate cellulaire inventé par John Conway en 1970. Il se base sur des règles très simples pour déterminer l'évolution d'un ensemble de cellules sur une grille. Cette simulation permet d'observer l'émergence de motifs complexes à partir d'états initialement simple.

Théorie et règles

Règles de base du jeu de la vie

A chaque génération, les règles suivantes s'appliquent simultanément à toutes les cellules :

(expliquer le principe de voisins : diagonale, haut, bas, gauche, droite)

- Une cellules vivante meurt si elle a moins de 2 ou plus de 3 voisins vivants (sous-population ou surpopulation)

- Une cellule vivante survit si elle a exactement 2 ou 3 voisins.

- Une cellule morte naît si elle a exactement 3 voisins vivants

Ces règles simples donnent naissance à une diversité de motifs et d'interactions.

Exemples de comportements

(Mettre des gif pour illustrer)

- Les oscillateurs - Les vaisseaux - Les structures stationnaires

Implémentation sur une grille finie

Structure de données utilisée

La version naïve repose sur un tableau à deux dimensions, où chaque élément représente l'état de la cellule (0 pour morte, 1 pour vivante).

Initialisation et affichage de la grille

L'affichage se fait via Tkinter, en dessinant des rectangles pour chaque cellule selon son état.

# Initialisation d'une grille de dimensions définies par l'utilisateur
cases = [[0 for _ in range(largeur)] for _ in range(hauteur)]

Calcul des voisins et évolution des cellules

L'évolution d'une cellule s'effectue ensuite en appliquant les règles selon le nombre de voisins vivants.

 def voisins_vivants(x, y):
    voisins = [(-1, -1), (-1, 0), (-1, 1), 
               (0, -1),           (0, 1),
               (1, -1),  (1, 0),  (1, 1)]
    nb_vivants = 0
    for dx, dy in voisins:
        nx, ny = x + dx, y + dy
        if 0 <= nx < hauteur and 0 <= ny < largeur:
            nb_vivants += cases[nx][ny]
    return nb_vivants

Avantages et limites de l'approche naïve

- Simple à comprendre et à implémenter.

- Utiles pour des grilles de petite taille.

- Gaspillage de mémoire pour de grandes tailles.

- Inadapté lorsque la majorité des cellules restent mortes.

Implémentation sur une grille infinie

Principe de stockage par dictionnaire

Pour simuler une grille infinie, seule l'information des cellules vivantes est stockée dans un dictionnaire.

Chaque clé représente les coordonnées d'une cellule vivante :

cases = {(x, y): 1, ...}

Gestion des cellules

Pour appliquer les règles, on ne parcourt pas l'ensemble de la grille mais seulement les cellules vivantes, leurs voisines potentielles.

for (x, y) in cases:
    candidats.add((x, y))
    for dx, dy in voisins:
        candidats.add((x + dx, y + dy))

Comparaison avec la grille finie

L'utilisation d'une dictionnaire pour stocker uniquement les cellules vivante est bien plus efficace en mémoire lorsque la densité de vie est faible. Elle est plus adapté aux grilles de grande taille, voire infinies, car elle évite de gérer un tableau complet.