Jeu de la vie, TP n°6

Utiliser le hasard (3)

Reprendre le programme précédent. Écrire une fonction qui compte les voisins de chaque cellule et qui affiche, pour chaque cellule, non plus le contenu, mais le nombre de voisins.
alea06.py [Cacher les numéros de ligne]
  1. # -*- coding: utf-8 -*-
  2. import random,curses
  3. ###################################
  4. ####    CREATION DU TABLEAU    ####
  5. ###################################
  6. def creation() :
  7.     global tableau
  8.     for l in range(nblgn) :                 # pour chaque ligne
  9.         tableau.append([""]*nbcol)          # créer la ligne vide
  10. ######################################
  11. ####    REMPLISSAGE DU TABLEAU    ####
  12. ######################################
  13. def remplissage() :
  14.     global tableau
  15.     proportion=random.random()              # proportion espace/étoile
  16.     for l in range(0,nblgn) :               # pour chaque ligne
  17.         for c in range(0,nbcol) :           # pour chaque colonne
  18.             if random.random()<proportion : # si tirage aléatoire dans la bonne proportion
  19.                 tableau[l][c]=vide          # ajouter un espace
  20.             else :                          # sinon
  21.                 tableau[l][c]=plein         # ajouter une étoile
  22. #########################
  23. ####    AFFICHAGE    ####
  24. #########################
  25. def affichage() :
  26.     for l in range(1,nblgn-1) :             # pour chaque ligne
  27.         for c in range(1,nbcol-1) :         # pour chaque colonne
  28.             # afficher la case correspondante au bon endroit
  29.             ecran.addstr(l+haut,c+gauche,str(voisins(l,c)))
  30. ###################################
  31. ####    COMPTER LES VOISINS    ####
  32. ###################################
  33. def voisins(l,c) :
  34.     lavant,lapres,cavant,capres=l-1,l+1,c-1,c+1        # les bornes d'exploration
  35.     if lavant<0 : lavant=nblgn-1                       # pour la ligne du haut
  36.     if lapres>=nblgn : lapres=0                        # pour la ligne du bas
  37.     if cavant<0 : cavant=nbcol-1                       # pour la colonne de gauche
  38.     if capres>=nbcol : capres=0                        # pour la colonne de droite
  39.     nbre=0                                             # initialisation du compteur
  40.     for ll in [lavant,l,lapres] :                      # pour les trois lignes entourant la case
  41.         for cc in [cavant,c,capres] :                  #  pour les trois colonnes entourant la case
  42.             # pour chaque case occupée qui n'est pas la case elle-même
  43.             if (ll!=l or cc!=c) and tableau[ll][cc]==plein :
  44.                 nbre+=1                                # ajouter 1 au compteur
  45.     return nbre                                        # retourner la valeur du compteur
  46. ####################################
  47. ####    ATTENTE ET FERMETURE    ####
  48. ####################################
  49. def finir() :
  50.     curses.endwin()                         # revenir à la console
  51.  
  52. ###############################
  53. ####    INITIALISATIONS    ####
  54. ###############################
  55. ecran=curses.initscr()                      # créer l'écran graphique
  56. ecran.nodelay(1)                            # getch() non bloquant
  57. curses.curs_set(False)                      # pas d'affichage du curseur
  58. gauche,droite=1,1                           # décalage horizontal
  59. haut,bas=1,2                                # décalage vertical
  60. nblgn,nbcol=ecran.getmaxyx()                # nombre de lignes et de colonnes
  61. nblgn=nblgn-haut-bas                        # ajuster en fonction des lignes vides
  62. nbcol=nbcol-gauche-droite                   # ajuster en fonction des colonnes vides
  63. sortie=[ord('q'),ord('Q')]                  # touches pour finir
  64. tableau=[]                                  # création du tableau vide
  65. plein="*"                                   # contenu d'une case pleine
  66. vide=" "                                    # contenu d'une case vide
  67. ##################################
  68. ####    CORPS DU PROGRAMME    ####
  69. ##################################
  70. creation()
  71. k=0                                         # initialisation pour rentrer dans la boucle
  72. while k not in sortie :                     # TQ on n'a pas appuyé sur une touche pour sortir
  73.     remplissage()                           # remplissage du terrain
  74.     affichage()                             # affichage du terrain
  75.     k=ecran.getch()                         # récupérér la touche sur laquelle on a appuyé
  76. finir()                                     # sortir de l'écran graphique
Dernière modification : 25/8/2016