Déroulement réel des cours

La « pensée » du joudi 21 oû 2019 , 22h21m18s :
Pourquoi les Kamikazes portaient-ils un casque?
1 : semaine du lendi 19 janbier 2009
 Cours n°1 (Cumul=2h) : [Voir le CM n°1]
2 : semaine du lendi 26 janbier 2009
 TD n°1 (Cumul=2h) : [Voir le TD n°1]
 Cours n°2 (Cumul=4h) : [Voir le CM n°2]
3 : semaine du lendi 2 fébrier 2009
 TD n°2 (Cumul=4h) : [Voir le TD n°2]
 Cours n°3 (Cumul=6h) : [Voir le CM n°3]
4 : semaine du lendi 9 fébrier 2009
 TD n°3 (Cumul=6h) : [Voir le TD n°3]
 Cours n°4 (Cumul=8h) : [Voir le CM n°4]
5 : semaine du lendi 16 fébrier 2009
 TD n°4 (Cumul=8h) : [Voir le TD n°4]
6 : semaine du lendi 2 môrs 2009
 TD n°5 (Cumul=10h) : [Voir le TD n°5]
7 : semaine du lendi 9 môrs 2009
 TD n°6 (Cumul=12h) : [Voir le TD n°6]
8 : semaine du lendi 16 môrs 2009
 TD n°7 (Cumul=15h) :
  • Assurez-vous que vous utilisez bien une fonction pour découvrir une case (comme dans la version précédente).
    Transformez cette fonction pour qu'elle provoque l'arrêt du programme si on découvre une mine. Quelques pistes pour guider votre réflexion :
    • Finir, ça veut dire sortir de la boucle qui gère le jeu.
    • Si on fait exploser une mine, il faudrait que les autres s'affichent aussi.
    demineur008.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##   H U I T I È M E    V E R S I O N     ##
    6. ##                                        ##
    7. ##          D U     P R O J E T           ##
    8. ##                                        ##
    9. ##            D É M I N E U R             ##
    10. ##                                        ##
    11. ############################################
    12. ############################################
    13. import random,curses
    14. ############################################
    15. #  I N I T I A L I S A T I O N S
    16. ############################################
    17. ecran=curses.initscr()  # création de l'écran "graphique"
    18. ecran.keypad(True)      # codage des touches de fonctions en 1 octet
    19. curses.curs_set(False)  # pas d'affichage du curseur
    20.  
    21. ############################################
    22. #  P A R A M È T R E S
    23. ############################################
    24. maxl=8              # nombre de lignes dans la grille
    25. maxc=14             # nombre de colonnes dans la grille
    26. ecarth=4            # écart entre deux lignes horizontales
    27. ecartv=3            # écart entre deux lignes verticales
    28. marcher=ord(" ")    # touche pour découvrir une cellule (marcher dessus)
    29. marquer=ord("*")    # touche pour marquer/démarquer une cellule
    30. quitter=ord("q")    # touche pour quitter
    31. terrain=[]          # création du terrain de jeu vide
    32. mines=[]            # création du tableau des mines vide
    33. probamarques=0.2    # probabilité d'apparition des marques
    34. COUVERTE=0          # état original des cases
    35. DECOUVERTE=1        # case découverte
    36. MARQUEE=2           # case marquée
    37. DESSINMINE="XXX"    # représentation d'une mine à l'écran
    38. PERDU=False         # passe à True quand on découvre, ce qui provoque l'arrêt du programme
    39.  
    40. ############################################
    41. # Pour les couleurs
    42. ############################################
    43. curses.start_color()
    44.  
    45. #  Jeu de couleurs pour le curseur
    46. COULEURCURSEUR=1
    47. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    48. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    49.  
    50. #  Jeu de couleurs pour la grille
    51. COULEURGRILLE=2
    52. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    53. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    54.  
    55. #  Jeu de couleurs pour une case couverte
    56. COULEURCOUVERTE=3
    57. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    58. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    59.  
    60. #  Jeu de couleurs pour une case découverte
    61. COULEURDECOUVERTE=4
    62. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    63. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    64.  
    65. #  Jeu de couleurs pour une case marquée
    66. COULEURMARQUE=5
    67. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    68. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    69.  
    70. #  Jeu de couleurs pour le texte en cas de mione explosée
    71. COULEURPERDU=6
    72. curses.init_pair(COULEURPERDU,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    73. TRAITPERDU=curses.color_pair(COULEURPERDU)+curses.A_BOLD+curses.A_BLINK
    74.  
    75. ############################################
    76. # Définition des caractères des cadres
    77. ############################################
    78. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    79. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    80. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    81. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    82. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    83. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    84. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    85. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    86. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    87. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    88. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    89.  
    90. ############################################
    91. #  F O N C T I O N S
    92. ############################################
    93. # == affichage de la grille ==
    94. def affichagegrille() :
    95.     # création des lignes verticales
    96.     for c in range(0,maxc+1) :                   # pour chaque ligne
    97.         for l in range(1,ecartv*maxl) :          # pour chaque case
    98.             # afficher un trait vertical
    99.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    100.     # création des lignes horizontales
    101.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    102.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    103.             if l==0 and c==0 :
    104.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    105.             elif l==0 and c == ecarth*maxc :
    106.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    107.             elif l==0 and c % ecarth == 0 :
    108.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    109.             elif l==maxl and c==0 :
    110.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    111.             elif l==maxl and c == ecarth*maxc :
    112.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    113.             elif l==maxl and c % ecarth == 0 :
    114.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    115.             elif c==0 :
    116.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    117.             elif c==ecarth*maxc :
    118.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    119.             elif c % ecarth == 0 :
    120.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    121.             else :
    122.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    123.     # affichage du contenu
    124.     for l in range(0,maxl) :                # pour chaque ligne
    125.         for c in range(0,maxc) :            # pour chaque colonne
    126.             l0=l*ecartv+1
    127.             c0=c*ecarth+1
    128.             if terrain[l][c]==MARQUEE :
    129.                 couleur=TRAITMARQUE         # couleur pour une marque
    130.                 remplir="X"                 # dessin pour une marque
    131.             elif terrain[l][c]==COUVERTE :
    132.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    133.                 remplir=" "                 # dessin pour case non découverte
    134.             else :
    135.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    136.                 remplir=" "                 # dessin pour case découverte
    137.             for ll in range(0,ecartv-1) :   # dessin de la case
    138.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    139.             if terrain[l][c]==DECOUVERTE :
    140.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    141.             if PERDU: # si perdu on affiche toutes les mines
    142.                 if mines[l][c] :
    143.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    144.  
    145. # == compter les voisins d'une case ==
    146. def voisins( lig , col ) :
    147.     # détermination des limites d'exploration
    148.     if lig==0 :      # si trop haut
    149.         l0=lig       # commencer sur cette ligne
    150.     else :           # sinon
    151.         l0=lig-1     # commencer à la ligne du dessus
    152.     if lig==maxl-1 : # si trop haut
    153.         l1=lig       # finir sur cette ligne
    154.     else :           # sinon
    155.         l1=lig+1     # finir sur la ligne du dessous
    156.     if col==0 :      # si trop à gauche
    157.         c0=col       # commencer sur cette colonne
    158.     else :           # sinon
    159.         c0=col-1     # commencer sur la colonne précédente
    160.     if col==maxc-1 : # si trop à droite
    161.         c1=col       # commencer sur cette colonne
    162.     else :           # sinon
    163.         c1=col+1     # commencer sur la colonne suivante
    164.     # exploration des cases voisines
    165.     n=0                             # initialisation du compteur
    166.     for l in range (l0,l1+1) :      # pour toutes les lignes
    167.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    168.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    169.                 if mines[l][c] :    # et que la case est minée
    170.                     n += 1          # incrémenter le compteur
    171.     # renvoyer les résultats
    172.     if n>0 :           # si il y a des voisins minés
    173.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    174.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    175.  
    176.  
    177. # == créer le terrain de jeu ==
    178. def creerleterrain() :
    179.     global terrain
    180.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    181.         terrain.append([])                      # ajouter une ligne au tableau
    182.         for c in range (0,maxc) :               # boucle sur chaque colonne
    183.             terrain[l].append(COUVERTE)         # créer la case
    184.  
    185. # == créer les mines ==
    186. def poserlesmines() :
    187.     global mines
    188.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    189.         mines.append([])                        # ajouter une ligne au tableau
    190.         for c in range (0,maxc) :               # boucle sur chaque colonne
    191.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    192.                 mines[l].append(True)           # cocher la case
    193.             else :                              # sinon
    194.                 mines[l].append(False)          # ne pas cocher
    195.  
    196. # ==  découvrir une case ==
    197. def decouvrir(l,c) :
    198.     global terrain
    199.     terrain[l][c]=DECOUVERTE
    200.  
    201. # ==  découvrir une case ==
    202. def changermarque(l,c) :
    203.     global terrain
    204.     if terrain[l][c]==COUVERTE :
    205.         terrain[l][c]=MARQUEE
    206.     elif  terrain[l][c]==MARQUEE :
    207.         terrain[l][c]=COUVERTE
    208.  
    209. # ==  afficher le curseur ==
    210. def affichecurseur(l,c) :
    211.     c0=c*ecarth     # colonne gauche
    212.     l0=l*ecartv     # ligne haut
    213.     c1=c0+ecarth    # colonne droite
    214.     l1=l0+ecartv    # ligne bas
    215.     # les coins
    216.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    217.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    218.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    219.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    220.     # les 2 bords horizontaux
    221.     for cc in range(c0+1,c1) :
    222.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    223.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    224.     # les 2 bords verticaux
    225.     for ll in range(l0+1,l1) :
    226.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    227.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    228.    
    229. ############################################
    230. #  C O R P S     D U    P R O G R A M M E
    231. ############################################
    232. poserlesmines()                               # créer les marques
    233. creerleterrain()                              # créer les marques
    234. ligne=1                                       # position verticale initiale du curseur
    235. colonne=1                                     # position horizontale initiale du curseur
    236. unetouche=0                                   # pour pouvoir entrer dans la boucle
    237. while unetouche!=quitter and PERDU==False :   # tant pas touche Q ni perdu...
    238.     # analyse de la frappe clavier
    239.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    240.         colonne += 1
    241.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    242.         colonne -= 1
    243.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    244.         ligne -= 1
    245.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    246.         ligne += 1
    247.     elif unetouche==marcher :                               # découvrir
    248.         decouvrir(ligne,colonne)
    249.         if mines[ligne][colonne] :
    250.             PERDU=True
    251.     elif unetouche==marquer :                               # marquer/démarquer
    252.         changermarque(ligne,colonne)
    253.     # (ré-)affichage du terrain
    254.     ecran.clear()                                           # effacer l'écran
    255.     affichagegrille()                                       # la grille
    256.     affichecurseur(ligne,colonne)                           # le curseur
    257.     # attente...
    258.     if PERDU==False :
    259.         unetouche=ecran.getch()                             # attente d'une frappe clavier
    260.  
    261. ############################################
    262. #  C ' E S T    P E R D U
    263. ############################################
    264. if PERDU :
    265.     ecran.addstr(1+maxl*ecartv,2,"                      ",TRAITPERDU)
    266.     ecran.addstr(2+maxl*ecartv,2,"  Vous avez perdu...  ",TRAITPERDU)
    267.     ecran.addstr(3+maxl*ecartv,2,"                      ",TRAITPERDU)
    268.     ecran.getch()                                           # attente d'une frappe clavier
    269.  
    270. ############################################
    271. #  F I N
    272. ############################################
    273. curses.endwin()  # revenir à la console
  • Transformez la fonction qui découvre une cellule pour qu'elle découvre aussi ses voisines si nécessaire...
    demineur009.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##    N E U V I È M E    V E R S I O N    ##
    6. ##                                        ##
    7. ##          D U     P R O J E T           ##
    8. ##                                        ##
    9. ##            D É M I N E U R             ##
    10. ##                                        ##
    11. ############################################
    12. ############################################
    13. import random,curses
    14. ############################################
    15. #  I N I T I A L I S A T I O N S
    16. ############################################
    17. ecran=curses.initscr()  # création de l'écran "graphique"
    18. ecran.keypad(True)      # codage des touches de fonctions en 1 octet
    19. curses.curs_set(False)  # pas d'affichage du curseur
    20.  
    21. ############################################
    22. #  P A R A M È T R E S
    23. ############################################
    24. maxl=8              # nombre de lignes dans la grille
    25. maxc=14             # nombre de colonnes dans la grille
    26. ecarth=4            # écart entre deux lignes horizontales
    27. ecartv=3            # écart entre deux lignes verticales
    28. marcher=ord(" ")    # touche pour découvrir une cellule (marcher dessus)
    29. marquer=ord("*")    # touche pour marquer/démarquer une cellule
    30. quitter=ord("q")    # touche pour quitter
    31. terrain=[]          # création du terrain de jeu vide
    32. mines=[]            # création du tableau des mines vide
    33. probamarques=0.1    # probabilité d'apparition des marques
    34. COUVERTE=0          # état original des cases
    35. DECOUVERTE=1        # case découverte
    36. MARQUEE=2           # case marquée
    37. DESSINMINE="XXX"    # représentation d'une mine à l'écran
    38. PERDU=False         # passe à True quand on découvre, ce qui provoque l'arrêt du programme
    39.  
    40. ############################################
    41. # Pour les couleurs
    42. ############################################
    43. curses.start_color()
    44.  
    45. #  Jeu de couleurs pour le curseur
    46. COULEURCURSEUR=1
    47. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    48. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    49.  
    50. #  Jeu de couleurs pour la grille
    51. COULEURGRILLE=2
    52. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    53. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    54.  
    55. #  Jeu de couleurs pour une case couverte
    56. COULEURCOUVERTE=3
    57. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    58. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    59.  
    60. #  Jeu de couleurs pour une case découverte
    61. COULEURDECOUVERTE=4
    62. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    63. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    64.  
    65. #  Jeu de couleurs pour une case marquée
    66. COULEURMARQUE=5
    67. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    68. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    69.  
    70. #  Jeu de couleurs pour le texte en cas de mione explosée
    71. COULEURPERDU=6
    72. curses.init_pair(COULEURPERDU,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    73. TRAITPERDU=curses.color_pair(COULEURPERDU)+curses.A_BOLD+curses.A_BLINK
    74.  
    75. ############################################
    76. # Définition des caractères des cadres
    77. ############################################
    78. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    79. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    80. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    81. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    82. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    83. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    84. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    85. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    86. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    87. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    88. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    89.  
    90. ############################################
    91. #  F O N C T I O N S
    92. ############################################
    93. # == affichage de la grille ==
    94. def affichagegrille() :
    95.     # création des lignes verticales
    96.     for c in range(0,maxc+1) :                   # pour chaque ligne
    97.         for l in range(1,ecartv*maxl) :          # pour chaque case
    98.             # afficher un trait vertical
    99.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    100.     # création des lignes horizontales
    101.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    102.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    103.             if l==0 and c==0 :
    104.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    105.             elif l==0 and c == ecarth*maxc :
    106.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    107.             elif l==0 and c % ecarth == 0 :
    108.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    109.             elif l==maxl and c==0 :
    110.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    111.             elif l==maxl and c == ecarth*maxc :
    112.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    113.             elif l==maxl and c % ecarth == 0 :
    114.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    115.             elif c==0 :
    116.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    117.             elif c==ecarth*maxc :
    118.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    119.             elif c % ecarth == 0 :
    120.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    121.             else :
    122.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    123.     # affichage du contenu
    124.     for l in range(0,maxl) :                # pour chaque ligne
    125.         for c in range(0,maxc) :            # pour chaque colonne
    126.             l0=l*ecartv+1
    127.             c0=c*ecarth+1
    128.             if terrain[l][c]==MARQUEE :
    129.                 couleur=TRAITMARQUE         # couleur pour une marque
    130.                 remplir="X"                 # dessin pour une marque
    131.             elif terrain[l][c]==COUVERTE :
    132.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    133.                 remplir=" "                 # dessin pour case non découverte
    134.             else :
    135.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    136.                 remplir=" "                 # dessin pour case découverte
    137.             for ll in range(0,ecartv-1) :   # dessin de la case
    138.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    139.             if terrain[l][c]==DECOUVERTE :
    140.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    141.             if PERDU: # si perdu on affiche toutes les mines
    142.                 if mines[l][c] :
    143.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    144.  
    145. # == compter les voisins d'une case ==
    146. def voisins( lig , col ) :
    147.     # détermination des limites d'exploration
    148.     if lig==0 :      # si trop haut
    149.         l0=lig       # commencer sur cette ligne
    150.     else :           # sinon
    151.         l0=lig-1     # commencer à la ligne du dessus
    152.     if lig==maxl-1 : # si trop haut
    153.         l1=lig       # finir sur cette ligne
    154.     else :           # sinon
    155.         l1=lig+1     # finir sur la ligne du dessous
    156.     if col==0 :      # si trop à gauche
    157.         c0=col       # commencer sur cette colonne
    158.     else :           # sinon
    159.         c0=col-1     # commencer sur la colonne précédente
    160.     if col==maxc-1 : # si trop à droite
    161.         c1=col       # commencer sur cette colonne
    162.     else :           # sinon
    163.         c1=col+1     # commencer sur la colonne suivante
    164.     # exploration des cases voisines
    165.     n=0                             # initialisation du compteur
    166.     for l in range (l0,l1+1) :      # pour toutes les lignes
    167.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    168.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    169.                 if mines[l][c] :    # et que la case est minée
    170.                     n += 1          # incrémenter le compteur
    171.     # renvoyer les résultats
    172.     if n>0 :           # si il y a des voisins minés
    173.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    174.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    175.  
    176.  
    177. # == créer le terrain de jeu ==
    178. def creerleterrain() :
    179.     global terrain
    180.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    181.         terrain.append([])                      # ajouter une ligne au tableau
    182.         for c in range (0,maxc) :               # boucle sur chaque colonne
    183.             terrain[l].append(COUVERTE)         # créer la case
    184.  
    185. # == créer les mines ==
    186. def poserlesmines() :
    187.     global mines
    188.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    189.         mines.append([])                        # ajouter une ligne au tableau
    190.         for c in range (0,maxc) :               # boucle sur chaque colonne
    191.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    192.                 mines[l].append(True)           # cocher la case
    193.             else :                              # sinon
    194.                 mines[l].append(False)          # ne pas cocher
    195.  
    196. # ==  découvrir une case ==
    197. def decouvrir(l,c) :
    198.     global terrain
    199.     terrain[l][c]=DECOUVERTE
    200.     if mines[l][c]!=True : # la cellule n'est pas minée
    201.         # lancement de l'exploration récursive
    202.         minCol=minLigne=-1 # bornes mini pour les voisins
    203.         maxCol=maxLigne=2  # bornes maxi pour les voisins
    204.         if voisins(l,c)=="" : # si aucun voisin ne contient de mine, lancer l'exploration
    205.             if c<1 : minCol=0            # réglage fin de la borne min en horizontal
    206.             if c>=maxc-1 : maxCol=1   # réglage fin de la borne max en horizontal
    207.             if l<1 : minLigne=0          # réglage fin de la borne min en vertical
    208.             if l>=maxl-1 : maxLigne=1 # réglage fin de la borne max en vertical
    209.             # explorer tous les voisins
    210.             for x in range(minCol,maxCol) :
    211.                 for y in range(minLigne,maxLigne) :
    212.                     if (x!=0)or(y!=0) : # sauf la cellule elle-même
    213.                         if terrain[y+l][x+c]==COUVERTE : # si la case n'a pas encore été explorée
    214.                             decouvrir(y+l,x+c)           # la découvrir (marcher dessus)
    215.  
    216. # ==  découvrir une case ==
    217. def changermarque(l,c) :
    218.     global terrain
    219.     if terrain[l][c]==COUVERTE :
    220.         terrain[l][c]=MARQUEE
    221.     elif  terrain[l][c]==MARQUEE :
    222.         terrain[l][c]=COUVERTE
    223.  
    224. # ==  afficher le curseur ==
    225. def affichecurseur(l,c) :
    226.     c0=c*ecarth     # colonne gauche
    227.     l0=l*ecartv     # ligne haut
    228.     c1=c0+ecarth    # colonne droite
    229.     l1=l0+ecartv    # ligne bas
    230.     # les coins
    231.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    232.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    233.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    234.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    235.     # les 2 bords horizontaux
    236.     for cc in range(c0+1,c1) :
    237.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    238.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    239.     # les 2 bords verticaux
    240.     for ll in range(l0+1,l1) :
    241.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    242.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    243.    
    244. ############################################
    245. #  C O R P S     D U    P R O G R A M M E
    246. ############################################
    247. poserlesmines()                               # créer les marques
    248. creerleterrain()                              # créer les marques
    249. ligne=1                                       # position verticale initiale du curseur
    250. colonne=1                                     # position horizontale initiale du curseur
    251. unetouche=0                                   # pour pouvoir entrer dans la boucle
    252. while unetouche!=quitter and PERDU==False :   # tant pas touche Q ni perdu...
    253.     # analyse de la frappe clavier
    254.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    255.         colonne += 1
    256.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    257.         colonne -= 1
    258.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    259.         ligne -= 1
    260.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    261.         ligne += 1
    262.     elif unetouche==marcher :                               # découvrir
    263.         decouvrir(ligne,colonne)
    264.         if mines[ligne][colonne] :
    265.             PERDU=True
    266.     elif unetouche==marquer :                               # marquer/démarquer
    267.         changermarque(ligne,colonne)
    268.     # (ré-)affichage du terrain
    269.     ecran.clear()                                           # effacer l'écran
    270.     affichagegrille()                                       # la grille
    271.     affichecurseur(ligne,colonne)                           # le curseur
    272.     # attente...
    273.     if PERDU==False :
    274.         unetouche=ecran.getch()                             # attente d'une frappe clavier
    275.  
    276. ############################################
    277. #  C ' E S T    P E R D U
    278. ############################################
    279. if PERDU :
    280.     ecran.addstr(1+maxl*ecartv,2,"                      ",TRAITPERDU)
    281.     ecran.addstr(2+maxl*ecartv,2,"  Vous avez perdu...  ",TRAITPERDU)
    282.     ecran.addstr(3+maxl*ecartv,2,"                      ",TRAITPERDU)
    283.     ecran.getch()                                           # attente d'une frappe clavier
    284.  
    285. ############################################
    286. #  F I N
    287. ############################################
    288. curses.endwin()  # revenir à la console
  • Ajoutez une fonction infos() qui affiche en permanence les informations suivantes à côté du terrain de jeu :
    • nombre total de cases,
    • nombre de cases découvertes,
    • nombres de mines,
    • nombres de cases marquées.
    demineur010.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##     D I X I È M E    V E R S I O N     ##
    6. ##                                        ##
    7. ##          D U     P R O J E T           ##
    8. ##                                        ##
    9. ##            D É M I N E U R             ##
    10. ##                                        ##
    11. ############################################
    12. ############################################
    13. import random,curses
    14. ############################################
    15. #  I N I T I A L I S A T I O N S
    16. ############################################
    17. ecran=curses.initscr()  # création de l'écran "graphique"
    18. ecran.keypad(True)      # codage des touches de fonctions en 1 octet
    19. curses.curs_set(False)  # pas d'affichage du curseur
    20.  
    21. ############################################
    22. #  P A R A M È T R E S
    23. ############################################
    24. maxl=8                # nombre de lignes dans la grille
    25. maxc=14               # nombre de colonnes dans la grille
    26. ecarth=4              # écart entre deux lignes horizontales
    27. ecartv=3              # écart entre deux lignes verticales
    28. marcher=ord(" ")      # touche pour découvrir une cellule (marcher dessus)
    29. marquer=ord("*")      # touche pour marquer/démarquer une cellule
    30. quitter=ord("q")      # touche pour quitter
    31. terrain=[]            # création du terrain de jeu vide
    32. mines=[]              # création du tableau des mines vide
    33. probamarques=0.1      # probabilité d'apparition des marques
    34. COUVERTE=0            # état original des cases
    35. DECOUVERTE=1          # case découverte
    36. MARQUEE=2             # case marquée
    37. DESSINMINE="XXX"      # représentation d'une mine à l'écran
    38. PERDU=False           # passe à True quand on découvre, ce qui provoque l'arrêt du programme
    39. NBREMARQUES=0         # nombre de marques posées sur le terrain
    40. NBREMINES=0           # nombre de mines
    41. NBREDECOUVERTES=0     # nombre de cases découvertes
    42. ############################################
    43. # Pour les couleurs
    44. ############################################
    45. curses.start_color()
    46.  
    47. #  Jeu de couleurs pour le curseur
    48. COULEURCURSEUR=1
    49. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    50. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    51.  
    52. #  Jeu de couleurs pour la grille
    53. COULEURGRILLE=2
    54. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    55. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    56.  
    57. #  Jeu de couleurs pour une case couverte
    58. COULEURCOUVERTE=3
    59. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    60. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    61.  
    62. #  Jeu de couleurs pour une case découverte
    63. COULEURDECOUVERTE=4
    64. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    65. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    66.  
    67. #  Jeu de couleurs pour une case marquée
    68. COULEURMARQUE=5
    69. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    70. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    71.  
    72. #  Jeu de couleurs pour le texte en cas de mine explosée
    73. COULEURPERDU=6
    74. curses.init_pair(COULEURPERDU,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    75. TRAITPERDU=curses.color_pair(COULEURPERDU)+curses.A_BOLD+curses.A_BLINK
    76.  
    77. #  Jeu de couleurs pour le texte d'information
    78. COULEURINFOS=7
    79. curses.init_pair(COULEURINFOS,curses.COLOR_WHITE,curses.COLOR_BLACK)
    80. TRAITINFOS=curses.color_pair(COULEURINFOS)
    81.  
    82. ############################################
    83. # Définition des caractères des cadres
    84. ############################################
    85. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    86. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    87. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    88. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    89. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    90. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    91. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    92. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    93. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    94. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    95. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    96.  
    97. ############################################
    98. #  F O N C T I O N S
    99. ############################################
    100. # == affichage des informations sur le jeu en cours ==
    101. def infos() :
    102.     l,c=2,maxc*ecarth+2
    103.     ecran.addstr(l  ,c,"Infos",TRAITINFOS+curses.A_BOLD)
    104.     ecran.addstr(l+1,c,"      Nombre de cases : "+str(maxc*maxl),TRAITINFOS)
    105.     ecran.addstr(l+2,c,"Nombre de découvertes : "+str(NBREDECOUVERTES),TRAITINFOS)
    106.     ecran.addstr(l+3,c,"    Nombre de marques : "+str(NBREMARQUES),TRAITINFOS)
    107.     ecran.addstr(l+4,c,"      Nombre de mines : "+str(NBREMINES),TRAITINFOS)
    108.  
    109. # == affichage de la grille ==
    110. def affichagegrille() :
    111.     # création des lignes verticales
    112.     for c in range(0,maxc+1) :                   # pour chaque ligne
    113.         for l in range(1,ecartv*maxl) :          # pour chaque case
    114.             # afficher un trait vertical
    115.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    116.     # création des lignes horizontales
    117.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    118.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    119.             if l==0 and c==0 :
    120.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    121.             elif l==0 and c == ecarth*maxc :
    122.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    123.             elif l==0 and c % ecarth == 0 :
    124.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    125.             elif l==maxl and c==0 :
    126.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    127.             elif l==maxl and c == ecarth*maxc :
    128.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    129.             elif l==maxl and c % ecarth == 0 :
    130.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    131.             elif c==0 :
    132.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    133.             elif c==ecarth*maxc :
    134.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    135.             elif c % ecarth == 0 :
    136.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    137.             else :
    138.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    139.     # affichage du contenu
    140.     for l in range(0,maxl) :                # pour chaque ligne
    141.         for c in range(0,maxc) :            # pour chaque colonne
    142.             l0=l*ecartv+1
    143.             c0=c*ecarth+1
    144.             if terrain[l][c]==MARQUEE :
    145.                 couleur=TRAITMARQUE         # couleur pour une marque
    146.                 remplir="X"                 # dessin pour une marque
    147.             elif terrain[l][c]==COUVERTE :
    148.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    149.                 remplir=" "                 # dessin pour case non découverte
    150.             else :
    151.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    152.                 remplir=" "                 # dessin pour case découverte
    153.             for ll in range(0,ecartv-1) :   # dessin de la case
    154.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    155.             if terrain[l][c]==DECOUVERTE :
    156.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    157.             if PERDU: # si perdu on affiche toutes les mines
    158.                 if mines[l][c] :
    159.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    160.  
    161. # == compter les voisins d'une case ==
    162. def voisins( lig , col ) :
    163.     # détermination des limites d'exploration
    164.     if lig==0 :      # si trop haut
    165.         l0=lig       # commencer sur cette ligne
    166.     else :           # sinon
    167.         l0=lig-1     # commencer à la ligne du dessus
    168.     if lig==maxl-1 : # si trop haut
    169.         l1=lig       # finir sur cette ligne
    170.     else :           # sinon
    171.         l1=lig+1     # finir sur la ligne du dessous
    172.     if col==0 :      # si trop à gauche
    173.         c0=col       # commencer sur cette colonne
    174.     else :           # sinon
    175.         c0=col-1     # commencer sur la colonne précédente
    176.     if col==maxc-1 : # si trop à droite
    177.         c1=col       # commencer sur cette colonne
    178.     else :           # sinon
    179.         c1=col+1     # commencer sur la colonne suivante
    180.     # exploration des cases voisines
    181.     n=0                             # initialisation du compteur
    182.     for l in range (l0,l1+1) :      # pour toutes les lignes
    183.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    184.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    185.                 if mines[l][c] :    # et que la case est minée
    186.                     n += 1          # incrémenter le compteur
    187.     # renvoyer les résultats
    188.     if n>0 :           # si il y a des voisins minés
    189.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    190.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    191.  
    192.  
    193. # == créer le terrain de jeu ==
    194. def creerleterrain() :
    195.     global terrain
    196.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    197.         terrain.append([])                      # ajouter une ligne au tableau
    198.         for c in range (0,maxc) :               # boucle sur chaque colonne
    199.             terrain[l].append(COUVERTE)         # créer la case
    200.  
    201. # == créer les mines ==
    202. def poserlesmines() :
    203.     global mines,NBREMINES
    204.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    205.         mines.append([])                        # ajouter une ligne au tableau
    206.         for c in range (0,maxc) :               # boucle sur chaque colonne
    207.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    208.                 mines[l].append(True)           # cocher la case
    209.                 NBREMINES+=1                    # compter les mines
    210.             else :                              # sinon
    211.                 mines[l].append(False)          # ne pas cocher
    212.  
    213. # ==  découvrir une case ==
    214. def decouvrir(l,c) :
    215.     global terrain,NBREDECOUVERTES
    216.     if terrain[l][c]!=DECOUVERTE : # si la case n'est pas déjà découverte
    217.         NBREDECOUVERTES+=1         # en compter une de plus
    218.     terrain[l][c]=DECOUVERTE
    219.     if mines[l][c]!=True : # la cellule n'est pas minée
    220.         # lancement de l'exploration récursive
    221.         minCol=minLigne=-1 # bornes mini pour les voisins
    222.         maxCol=maxLigne=2  # bornes maxi pour les voisins
    223.         if voisins(l,c)=="" : # si aucun voisin ne contient de mine, lancer l'exploration
    224.             if c<1 : minCol=0            # réglage fin de la borne min en horizontal
    225.             if c>=maxc-1 : maxCol=1   # réglage fin de la borne max en horizontal
    226.             if l<1 : minLigne=0          # réglage fin de la borne min en vertical
    227.             if l>=maxl-1 : maxLigne=1 # réglage fin de la borne max en vertical
    228.             # explorer tous les voisins
    229.             for x in range(minCol,maxCol) :
    230.                 for y in range(minLigne,maxLigne) :
    231.                     if (x!=0)or(y!=0) : # sauf la cellule elle-même
    232.                         if terrain[y+l][x+c]==COUVERTE : # si la case n'a pas encore été explorée
    233.                             decouvrir(y+l,x+c)           # la découvrir (marcher dessus)
    234.  
    235. # ==  découvrir une case ==
    236. def changermarque(l,c) :
    237.     global terrain,NBREMARQUES
    238.     if terrain[l][c]==COUVERTE :
    239.         terrain[l][c]=MARQUEE
    240.         NBREMARQUES+=1
    241.     elif  terrain[l][c]==MARQUEE :
    242.         terrain[l][c]=COUVERTE
    243.         NBREMARQUES-=1
    244.  
    245. # ==  afficher le curseur ==
    246. def affichecurseur(l,c) :
    247.     c0=c*ecarth     # colonne gauche
    248.     l0=l*ecartv     # ligne haut
    249.     c1=c0+ecarth    # colonne droite
    250.     l1=l0+ecartv    # ligne bas
    251.     # les coins
    252.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    253.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    254.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    255.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    256.     # les 2 bords horizontaux
    257.     for cc in range(c0+1,c1) :
    258.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    259.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    260.     # les 2 bords verticaux
    261.     for ll in range(l0+1,l1) :
    262.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    263.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    264.    
    265. ############################################
    266. #  C O R P S     D U    P R O G R A M M E
    267. ############################################
    268. poserlesmines()                               # créer les marques
    269. creerleterrain()                              # créer les marques
    270. ligne=1                                       # position verticale initiale du curseur
    271. colonne=1                                     # position horizontale initiale du curseur
    272. unetouche=0                                   # pour pouvoir entrer dans la boucle
    273. while unetouche!=quitter and PERDU==False :   # tant pas touche Q ni perdu...
    274.     # analyse de la frappe clavier
    275.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    276.         colonne += 1
    277.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    278.         colonne -= 1
    279.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    280.         ligne -= 1
    281.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    282.         ligne += 1
    283.     elif unetouche==marcher :                               # découvrir
    284.         decouvrir(ligne,colonne)
    285.         if mines[ligne][colonne] :
    286.             PERDU=True
    287.     elif unetouche==marquer :                               # marquer/démarquer
    288.         changermarque(ligne,colonne)
    289.     # (ré-)affichage du terrain
    290.     ecran.clear()                                           # effacer l'écran
    291.     affichagegrille()                                       # la grille
    292.     affichecurseur(ligne,colonne)                           # le curseur
    293.     infos()                                                 # informations sur le jeu en cours
    294.     # attente...
    295.     if PERDU==False :
    296.         unetouche=ecran.getch()                             # attente d'une frappe clavier
    297.  
    298. ############################################
    299. #  C ' E S T    P E R D U
    300. ############################################
    301. if PERDU :
    302.     ecran.addstr(1+maxl*ecartv,2,"                      ",TRAITPERDU)
    303.     ecran.addstr(2+maxl*ecartv,2,"  Vous avez perdu...  ",TRAITPERDU)
    304.     ecran.addstr(3+maxl*ecartv,2,"                      ",TRAITPERDU)
    305.     ecran.getch()                                           # attente d'une frappe clavier
    306.  
    307. ############################################
    308. #  F I N
    309. ############################################
    310. curses.endwin()  # revenir à la console
Dernière modification : 25/8/2016
9 : semaine du lendi 23 môrs 2009
 TD n°8 (Cumul=18h) : [Voir le TD n°8]
Dernière modification : 25/8/2016