Jeu de la vie, TP n°8

Compter les générations

Compter les générations et les afficher en bas de l'écran en temps réel. Ajouter également un message d'information qui dit comment sortir du « jeu ».
vie02.py [Cacher les numéros de ligne]
  1. # -*- coding: utf-8 -*-
  2. import random,curses
  3.  
  4. #####################################
  5. ####    CREATION DES TABLEAUX    ####
  6. #####################################
  7. def creation() :
  8.     global tableau
  9.     for l in range(0,nblgn) :               # pour chaque ligne
  10.         tableau.append([vide]*nbcol)        # créer la ligne
  11.         prochaine.append([vide]*nbcol)      # créer la ligne
  12.  
  13. ##############################################
  14. ####    PREMIER REMPLISSAGE DU TABLEAU    ####
  15. ##############################################
  16. def remplissage() :
  17.     global tableau
  18.     proportion=random.random()              # proportion espace/étoile
  19.     for l in range(0,nblgn) :               # pour chaque ligne
  20.         for c in range(0,nbcol) :           # pour chaque colonne
  21.             if random.random()<proportion : # si tirage aléatoire dans la bonne proportion
  22.                 tableau[l][c]=vide          # ajouter un espace
  23.             else :                          # sinon
  24.                 tableau[l][c]=plein         # ajouter une étoile
  25.  
  26. #################################################
  27. ####    CALCUL DE LA PROCHAINE GÉNÉRATION    ####
  28. #################################################
  29. def generation() :
  30.     global tableau,prochaine,generations
  31.     for l in range(0,nblgn) :               # pour chaque ligne
  32.         for c in range(0,nbcol) :           # pour chaque colonne
  33.             n=voisins(l,c)                  # nombres de voisiuns de la case
  34.             #  si (case vivante avec 2 voisins) ou si 3 voisins
  35.             if (n==2 and tableau[l][c]==plein) or (n==3) :
  36.                 prochaine[l][c]=plein       # case vivante à la prochaine génération
  37.             else :
  38.                 prochaine[l][c]=vide        # case vide à la prochaine génération
  39.     for l in range(0,nblgn) :               # pour chaque ligne
  40.         for c in range(0,nbcol) :           # pour chaque colonne
  41.             tableau[l][c]=prochaine[l][c]   # recopier la nouvelle génération
  42.     generations+=1                          # une génération de plus
  43.  
  44. #########################
  45. ####    AFFICHAGE    ####
  46. #########################
  47. def affichage() :
  48.     for l in range(0,nblgn) :                # pour chaque ligne
  49.         for c in range(0,nbcol) :            # pour chaque colonne
  50.             ecran.addstr(l+haut,c+gauche,tableau[l][c])  # case correspondante
  51.     ecran.addstr(nblgn+haut,gauche,str(generations)+"° génération. ") #  n° de génération
  52.     ou=""                                    # entre les choix (vide pour le 1er)
  53.     sortir=""                                # message à afficher
  54.     for q in sortie :                        # pour toutes les touches de sortie
  55.         sortir=sortir+ou+"« "+chr(q)+" »"    # ajouter la touche
  56.         ou=" ou "                            # entre les choix ("ou" à partir du 2°)
  57.     ecran.addstr("Pour sortir, appuyer sur "+sortir+".") # afficher le message
  58.  
  59. ###################################
  60. ####    COMPTER LES VOISINS    ####
  61. ###################################
  62. def voisins(l,c) :
  63.     lavant,lapres,cavant,capres=l-1,l+1,c-1,c+1 # les bornes d'exploration
  64.     if lavant<0 : lavant=nblgn-1                # pour la ligne du haut
  65.     if lapres>=nblgn : lapres=0                 # pour la ligne du bas
  66.     if cavant<0 : cavant=nbcol-1                # pour la colonne de gauche
  67.     if capres>=nbcol : capres=0                 # pour la colonne de droite
  68.     nbre=0                                      # initialisation du compteur
  69.     for ll in [lavant,l,lapres] :               # pour les 3 lignes entourant la case
  70.         for cc in [cavant,c,capres] :           # pour les 3 colonnes entourant la case
  71.             # pour chaque case occupée qui n'est pas la case elle-même
  72.             if (ll!=l or cc!=c) and tableau[ll][cc]==plein :
  73.                 nbre+=1                         # ajouter 1 au compteur
  74.     return nbre                                 # retourner la valeur du compteur
  75.  
  76. ####################################
  77. ####    ATTENTE ET FERMETURE    ####
  78. ####################################
  79. def finir() :
  80.     curses.endwin()                                    # revenir à la console
  81.  
  82. ###############################
  83. ####    INITIALISATIONS    ####
  84. ###############################
  85. ecran=curses.initscr()            # créer l'écran graphique
  86. ecran.nodelay(1)                  # getch() non bloquant
  87. curses.curs_set(False)            # pas d'affichage du curseur
  88. gauche,droite=1,1                 # décalage horizontal
  89. haut,bas=1,2                      # décalage vertical
  90. nblgn,nbcol=ecran.getmaxyx()      # nombre de lignes et de colonnes
  91. nblgn=nblgn-haut-bas              # ajuster en fonction des lignes vides
  92. nbcol=nbcol-gauche-droite         # ajuster en fonction des colonnes vides
  93. sortie=[ord('q'),ord('Q')]        # touches pour finir
  94. tableau=[]                        # création du tableau vide
  95. prochaine=[]                      # création du tableau pour la prochaine génération
  96. plein="*"                         # contenu d'une case pleine
  97. vide=" "                          # contenu d'une case vide
  98. generations=0                     # nombre de générations
  99.  
  100. ##################################
  101. ####    CORPS DU PROGRAMME    ####
  102. ##################################
  103. creation()                    # création des tableaux
  104. remplissage()                 # remplissage initial du tableau
  105. k=0                           # initialisation pour rentrer dans la boucle
  106. while k not in sortie :       # TQ on n'a pas appuyé sur une touche pour sortir
  107.     affichage()               # affichage de la génération courante
  108.     generation()              # calcul de la génération suivante
  109.     k=ecran.getch()           # récupérér la touche sur laquelle on a appuyé
  110. finir()                       # sortir de l'écran graphique
Dernière modification : 25/8/2016