Jeu de la vie, TP n°7

Première ébauche

Premiers pas vers le vrai programme. Réorganiser et compléter ce qui a été écrit précédemment :
vie01.py [Cacher les numéros de ligne]
  1. # -*- coding: utf-8 -*-
  2. import random,curses
  3.  
  4. #####################################
  5. ####    CRÉATION 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
  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.  
  43. #########################
  44. ####    AFFICHAGE    ####
  45. #########################
  46. def affichage() :
  47.     for l in range(0,nblgn) :               # pour chaque ligne
  48.         for c in range(0,nbcol) :           # pour chaque colonne
  49.             # afficher la case correspondante au bon endroit
  50.             ecran.addstr(l+haut,c+gauche,tableau[l][c])
  51.  
  52. ###################################
  53. ####    COMPTER LES VOISINS    ####
  54. ###################################
  55. def voisins(l,c) :
  56.     lavant,lapres,cavant,capres=l-1,l+1,c-1,c+1   # les bornes d'exploration
  57.     if lavant<0 : lavant=nblgn-1                  # pour la ligne du haut
  58.     if lapres>=nblgn : lapres=0                   # pour la ligne du bas
  59.     if cavant<0 : cavant=nbcol-1                  # pour la colonne de gauche
  60.     if capres>=nbcol : capres=0                   # pour la colonne de droite
  61.     nbre=0                                        # initialisation du compteur
  62.     for ll in [lavant,l,lapres] :                 # pour les 3 lignes entourant la case
  63.         for cc in [cavant,c,capres] :             #  pour les 3 colonnes entourant la case
  64.             # pour chaque case occupée qui n'est pas la case elle-même
  65.             if (ll!=l or cc!=c) and tableau[ll][cc]==plein :
  66.                 nbre+=1                           # ajouter 1 au compteur
  67.     return nbre                                   # retourner la valeur du compteur
  68.  
  69. ####################################
  70. ####    ATTENTE ET FERMETURE    ####
  71. ####################################
  72. def finir() :
  73.     curses.endwin()                                    # revenir à la console
  74.  
  75. ###############################
  76. ####    INITIALISATIONS    ####
  77. ###############################
  78. ecran=curses.initscr()             # créer l'écran graphique
  79. ecran.nodelay(1)                   # getch() non bloquant
  80. curses.curs_set(False)             # pas d'affichage du curseur
  81. gauche,droite=1,1                  # décalage horizontal
  82. haut,bas=1,2                       # décalage vertical
  83. nblgn,nbcol=ecran.getmaxyx()       # nombre de lignes et de colonnes
  84. nblgn=nblgn-haut-bas               # ajuster en fonction des lignes vides
  85. nbcol=nbcol-gauche-droite          # ajuster en fonction des colonnes vides
  86. sortie=[ord('q'),ord('Q')]         # touches pour finir
  87. tableau=[]                         # création du tableau vide
  88. prochaine=[]                       # création du tableau pour la prochaine génération
  89. plein="*"                          # contenu d'une case pleine
  90. vide=" "                           # contenu d'une case vide
  91.  
  92. ##################################
  93. ####    CORPS DU PROGRAMME    ####
  94. ##################################
  95. creation()                       # création des tableaux
  96. remplissage()                    # remplissage initial du tableau
  97. k=0                              # initialisation pour rentrer dans la boucle
  98. while k not in sortie :          # TQ on n'a pas appuyé sur une touche pour sortir
  99.     affichage()                  # affichage de la génération courante
  100.     generation()                 # calcul de la génération suivante
  101.     k=ecran.getch()              # récupérér la touche sur laquelle on a appuyé
  102. finir()                          # sortir de l'écran graphique
Dernière modification : 25/8/2016