Jeu de la vie

Le Jeu de la vie (ou Game of Life) est un automate cellulaire inventé par le mathématicien britannique John Horton Conway en 1970. C'est un modèle mathématique qui simule l'évolution de cellules sur une grille en fonction de règles simples. Chaque cellule peut être vivante ou morte, et son état évolue à chaque génération selon le nombre de voisins vivants. Pour plus de détails, vous pouvez consulter la page Wikipedia du Jeu de la vie.

Une cellule qui a 3 voisins peut naitre, ou rester en vie.

Une cellule qui a 2 voisins reste dans le même état (morte ou vivante).

Dans les autres acs, la cellule meurt.

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
from random import randint

class Cellule:
    def __init__(self, vie):
        self.vie = vie
        self.voisins = []

    def vivre(self):
        self.vie = 1

    def mort(self):
        self.vie = 0

    def ajoutVoisin(self, voisin):
        self.voisins.append(voisin)

    def nbVoisinsEnVie(self):
        return sum(1 for v in self.voisins if v.vie) # parcours des voisins a qui on attribue 1 si en vie

class Jeu:
    def __init__(self, taille):
        self.taille = taille
        # grille contient une matrice d'objets Cellules de taille : self.taille * self.taille
        self.grille = [[Cellule(randint(0,1)) for i in range(self.taille)] for j in range(self.taille)]

        # ajout des voisins
        delta = [-1,0,1]
        for i in range(taille):
            for j in range(taille):
                for deltaI in delta:
                    for deltaJ in delta:
                        if (i + deltaI) in range(taille) and (j + deltaJ) in range(taille):
                            if deltaI != 0 or deltaJ != 0:
                                self.grille[i][j].ajoutVoisin(self.grille[i + deltaI][j + deltaJ])



    def __str__(self):
        '''
        retourne un chaine de  / * (espace: cellule morte, *: cellule vivante )
        exemple
        '     *   *  \n
         **** * *    \n
            *   *   *\n
        ...

        '''
        chaine = ''
        ligne = ''
        for l in self.grille:
            ligne = ''
            for c in l:
                ligne += '*' if c.vie else ' '
            ligne += '\n'
            chaine += ligne
        return chaine

    def evolue(self):
        for l in self.grille:
            for c in l:
                nbVoisins = c.nbVoisinsEnVie()
                if nbVoisins == 3:
                    c.vivre()
                elif nbVoisins < 2 or nbVoisins > 3:
                    c.mort()


# Exemple d'utilisation
taille = 10
jeu = Jeu(taille)
print(jeu)  # Affiche l'état initial
jeu.evolue()  # Fait évoluer le jeu
print(jeu)  # Affiche l'état après évolution

Cette implémentation crée un jeu de la vie avec une grille de cellules, où chaque cellule évolue selon les règles définies. La méthode __str__ permet d'afficher la grille de manière lisible, et la méthode evolue applique les règles de vie à chaque cellule.