Skip to content

Le Jeu de la vie est un automate cellulaire imaginé par John Horton Conway en 1970. Malgré des règles très simples, il est Turing-complet. C'est un jeu de simulation au sens mathématique. que j'ai ecrit en python

Notifications You must be signed in to change notification settings

Ilyes-El-Majouti/game-of-life

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

8 Commits
 
 
 
 

Repository files navigation

Jeu de la vie

Le jeu de la vie est une modélisation simpliste de la vie de cellules dans l'espace. Dans le cadre de cet exercice l'espace sera une grille rectangulaire dont chaque case peut contenir au plus une cellule. Chaque case contiendra donc soit 0 soit 1 cellule en vie.
Les voisines prises en compte sont toutes les cases situées immédiatement à gauche, à droite, en haut, en bas ou sur les quatre diagonales, si elles existent. Une case a donc au plus 8 voisines, moins si elle se situe sur un bord de la grille:
voisines
Les cellules peuvent émerger ou mourir selon des critères précis à réévaluer à chaque nouvelle génération :
  • Une cellule émergera dans une case qui possède exactement trois voisines avec une cellule:
3voisins
Une cellule disparaît de sa case si elle est entourée par strictement moins de deux cellules vivantes ou strictement plus de trois cellules vivantes:
0 voisin 1 voisin 4 voisin 5 voisin
0 1 4 5
  • Les autres cases restent dans leur état:
2 voisins ==> 2

Représentation d'une grille

Du point de vue technique une grille du jeu de la vie sera représentée par une liste de listes de nombre entiers. Chaque nombre entier représente le nombre de cellules vivantes dans une case de la grille (0 ou 1). Par exemple la liste :
[ [0, 1, 0], [1, 0, 0] ]
représente une grille de jeu de 6 cases:
  • 3 cases en largeur
  • 2 cases en hauteur.
Sur la première ligne seule la deuxième case possède une cellule (vie), tandis que sur la deuxième ligne, seule la première case en possède une (vie).
colonne 1 colonne 2 colonne 3
ligne 1 0 1 0
ligne 2 1 0 0

I. Implémentation

1. Construction d'une grille aléatoire

Q1. Créez un nouveau fichier jeu_de_la_vie.py dans un dossier* JeuVie* sur votre bureau Ubuntu.
Q2. Déclarez une classe JeuVie avec son constructeur:

création du constructeur: init()

  • Voici le doc string du constructeur:
"""
Création d'une grille 2D avec deux paramètres ligne et colonne.
Initialisation de la grille avec des valeurs aléatoires
(1=vivant ou 0=mort)
"""
  • Implémentez votre constructeur afin d'instancier les deux attributs ligne et colonne.
  • Ajoutez à votre constructeur un contrôle de paramètres non vide sur les variables ligne et colonne. Vous utiliserez l'instruction assert qui retournera le message d'erreur suivant:
'attention aux paramètres ligne colonne non vide'
On désire à présent compléter le constructeur en ajoutant l'attribut d'instance monde qui correspond à la grille ligne∗colonneligne * colonneligne∗colonne avec des valeurs aléatoires (0 ou1):
exemple1: grille pour ligne=3 et colonne=2:
[[0, 0], [0, 0], [1, 1]]
exemple2: grille pour ligne=5 et colonne=3:
[[0, 0, 0], [0, 1, 0], [0, 1, 1], [1, 1, 1], [1, 1, 0]]
  • implémenter l'attribut d'instance monde en créant une grille:
    • avec des valeurs aléatoires ("0" ou "1") en utilisant la méthode choice() de la classe random;
    • par compréhension avec des relations ligne colonne.
Remarque: Il est recommandé de réaliser des testes dans le shell avant de l'implémenter dans la classe JeuVie. Vous pourrez également visualiser la construction par compréhension sur Python Tutor (Python Tutor - Visualize Python, Java, JavaScript, C, C , Ruby code execution)

2. Affichage de la grille: méthode str()

Q3. Déclarez une méthode str().
  • Voici le doc string / doc test de la méthode str:
"""
Affiche la grille avec les symboles graphiques du dictionnaire cells
>>> grille = JeuVie(5,5)
>>> grille.monde = [[0, 1, 0, 0, 0],[0, 0, 1, 0, 0],[1, 1, 1, 0, 0],[0, 0, 0, 0, 0],[0, 0, 0, 0, 0]]
>>> print(grille)
.#...
..#..
###..
.....
.....
"""
Vous remarquerez que:
  • les "1" sont représentés par le symbole "#";
  • les "0" sont représentés par le symbole "."
Q4. Ajoutez à votre classe JeuVie un attribut de classe cells de type dictionnaire, qui permettra l'affichage des symboles "#" et ".".
Q5. Implémentez votre méthode str afin d'afficher la grille en la parcourant.

3. Tester si dans la grille: méthode get_grille()

Il est nécessaire pour la suite de s'avoir si les coordonnées pointées par un numéro de ligne et de colonne appartiennent bien à la grille. Cette méthode retournera:
  • la valeur de la case pointée s'il elle est dans la grille;
  • la valeur False si la case pointée n'est pas dans la grille.
Q6. Implémentez votre méthode get_grille() qui prend en paramètres:
  • l : (int) correspondant à la ligne pointée
  • c:(int) correspondant à la colonne pointée
Voici un teste de la méthode get_grille():
>>> grille = JeuVie(4,4)
>>> grille.monde = [[0, 0, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0]]
>>> grille.get_grille(-1,2)
False
>>> grille.get_grille(2,0)
1

4. Evolution des cellules: méthode evolution_cell()

Cette méthode revoie le nouvel état de la cellule pointée par sa position (ligne, colonne) en respectant les règles d'évolution du jeu.
Q7. Implémentez votre méthode evolution_cell() qui prend en paramètre la ligne et la colonne de la cellule pointée.
Voici les étapes à respectées pour implémenter votre méthode:
  1. Parcourir les cellules voisines et compter le nombre de True (ou "1")
  2. Appliquer les règles d'évolution du jeu, en fonction du nombre de True trouvé, pour déterminer le nouvel état de la cellule
  3. Retourner la valeur du nouvel état de la cellule pointée
Voici un test de la méthode evolution_cell():
>>> grille = JeuVie(4,4)
>>> grille.monde = [[0, 0, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0]]
>>> grille.evolution_cell(0,2)
False
>>> grille.evolution_cell(2,1)
True

5. Evolution du jeu: méthode evolution_jeu()

Cette méthode "reconstruit" la grille, par compréhension, avec les nouveaux états des cellules.
Q8. Implémentez votre méthode evolution_jeu() qui ne prend aucun paramètre.
Voici un test de la méthode evolution_jeu():
>>> grille = JeuVie(4,4)
>>> grille.monde = [[0, 0, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0]]
>>> grille.evolution_jeu()
>>> grille.monde
[[0, 0, 0, 0], [0, 1, 1, 1], [1, 1, 1, 0], [0, 0, 0, 0]]
>>> grille.evolution_jeu()
>>> grille.monde
[[0, 0, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0]]

6. Test du programme et de la classe JeuVie

Ajouter à la fin de votre programme le code suivant:
#importer la classe time
import time

if __name__ == '__main__':
    #Instanciation de l'objet grille avec 10 lignes et 10 colonnes
    grille = ..........................
    print(grille)
    rep = 0
    #repeter 20 fois
    while .........:
        print("Répétition= ",rep)
        #appliquer une évolution du jeu à l'objet grille
        ............................
        time.sleep(0.2)
        print(grille)
        #Incrémenter la variable locale x
        rep = .....................
Q9. En vous aidant des commentaires, complétez puis testez votre code.

Motifs récurrents

Quelques motifs récurrents peuvent être obtenus à partir de grilles particulières.
Par exemple, un oscillateur à deux états peut être obtenu avec cette grille :
self.monde = [[0, 0, 1, 0],
              [1, 0, 0, 1],
              [1, 0, 0, 1],
              [0, 1, 0, 0]]
ou encore celle-ci:
self.monde = [[0, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0],
              [0, 0, 1, 1, 1, 0],
              [0, 1, 1, 1, 0, 0],
              [0, 0, 0, 0, 0, 0],
              [0, 0, 0, 0, 0, 0]]
Autre exemple avec 15 états différents:
self.monde = [[0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,1,0,0,0,0,0],
              [0,0,0,0,1,1,1,0,0,0,0],
              [0,0,0,1,1,1,1,1,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,1,1,1,1,1,0,0,0],
              [0,0,0,0,1,1,1,0,0,0,0],
              [0,0,0,0,0,1,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0,0,0],]

Ressources additionnelles

Vous trouverez des motifs plus complexes sur la page Wikipedia du jeu de la vie, en particulier dans sa version anglophone. Cette vidéo didactique de David Louapre présente le jeu de la vie et des structures complexes.

About

Le Jeu de la vie est un automate cellulaire imaginé par John Horton Conway en 1970. Malgré des règles très simples, il est Turing-complet. C'est un jeu de simulation au sens mathématique. que j'ai ecrit en python

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages