Déroulement réel des cours

La « pensée » du vendredi 15 février 2019, 22h59m48s :
All I ask is a chance to prove that money can't make me happy.
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) : [Voir le TD n°7]
9 : semaine du lendi 23 môrs 2009
 TD n°8 (Cumul=18h) :
  • La fonction infos() doit aussi afficher le temps écoulé. Comment faire pour que le temps passé s'affiche en continu ?
    demineur011.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##     O N Z 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,time
    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. TPSDEBUT=time.time()      #  Top départ, pour le calcul du temps passé
    83.  
    84. ############################################
    85. # Définition des caractères des cadres
    86. ############################################
    87. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    88. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    89. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    90. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    91. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    92. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    93. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    94. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    95. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    96. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    97. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    98.  
    99. ############################################
    100. #  F O N C T I O N S
    101. ############################################
    102. # == affichage des informations sur le jeu en cours ==
    103. def infos() :
    104.     l,c=2,maxc*ecarth+2
    105.     ecran.addstr(l  ,c,"Infos",TRAITINFOS+curses.A_BOLD)
    106.     ecran.addstr(l+1,c,"      Nombre de cases :  "+str(maxc*maxl),TRAITINFOS)
    107.     ecran.addstr(l+2,c,"Nombre de découvertes :  "+str(NBREDECOUVERTES),TRAITINFOS)
    108.     ecran.addstr(l+3,c,"    Nombre de marques :  "+str(NBREMARQUES),TRAITINFOS)
    109.     ecran.addstr(l+4,c,"      Nombre de mines :  "+str(NBREMINES),TRAITINFOS)
    110.     ecran.addstr(l+5,c,"     Temps écoulé (s) : ")
    111.     ecran.addstr(l+5,c+25,str(int(time.time()-TPSDEBUT)))
    112.  
    113. # == affichage de la grille ==
    114. def affichagegrille() :
    115.     # création des lignes verticales
    116.     for c in range(0,maxc+1) :                   # pour chaque ligne
    117.         for l in range(1,ecartv*maxl) :          # pour chaque case
    118.             # afficher un trait vertical
    119.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    120.     # création des lignes horizontales
    121.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    122.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    123.             if l==0 and c==0 :
    124.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    125.             elif l==0 and c == ecarth*maxc :
    126.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    127.             elif l==0 and c % ecarth == 0 :
    128.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    129.             elif l==maxl and c==0 :
    130.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    131.             elif l==maxl and c == ecarth*maxc :
    132.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    133.             elif l==maxl and c % ecarth == 0 :
    134.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    135.             elif c==0 :
    136.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    137.             elif c==ecarth*maxc :
    138.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    139.             elif c % ecarth == 0 :
    140.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    141.             else :
    142.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    143.     # affichage du contenu
    144.     for l in range(0,maxl) :                # pour chaque ligne
    145.         for c in range(0,maxc) :            # pour chaque colonne
    146.             l0=l*ecartv+1
    147.             c0=c*ecarth+1
    148.             if terrain[l][c]==MARQUEE :
    149.                 couleur=TRAITMARQUE         # couleur pour une marque
    150.                 remplir="X"                 # dessin pour une marque
    151.             elif terrain[l][c]==COUVERTE :
    152.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    153.                 remplir=" "                 # dessin pour case non découverte
    154.             else :
    155.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    156.                 remplir=" "                 # dessin pour case découverte
    157.             for ll in range(0,ecartv-1) :   # dessin de la case
    158.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    159.             if terrain[l][c]==DECOUVERTE :
    160.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    161.             if PERDU: # si perdu on affiche toutes les mines
    162.                 if mines[l][c] :
    163.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    164.  
    165. # == compter les voisins d'une case ==
    166. def voisins( lig , col ) :
    167.     # détermination des limites d'exploration
    168.     if lig==0 :      # si trop haut
    169.         l0=lig       # commencer sur cette ligne
    170.     else :           # sinon
    171.         l0=lig-1     # commencer à la ligne du dessus
    172.     if lig==maxl-1 : # si trop haut
    173.         l1=lig       # finir sur cette ligne
    174.     else :           # sinon
    175.         l1=lig+1     # finir sur la ligne du dessous
    176.     if col==0 :      # si trop à gauche
    177.         c0=col       # commencer sur cette colonne
    178.     else :           # sinon
    179.         c0=col-1     # commencer sur la colonne précédente
    180.     if col==maxc-1 : # si trop à droite
    181.         c1=col       # commencer sur cette colonne
    182.     else :           # sinon
    183.         c1=col+1     # commencer sur la colonne suivante
    184.     # exploration des cases voisines
    185.     n=0                             # initialisation du compteur
    186.     for l in range (l0,l1+1) :      # pour toutes les lignes
    187.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    188.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    189.                 if mines[l][c] :    # et que la case est minée
    190.                     n += 1          # incrémenter le compteur
    191.     # renvoyer les résultats
    192.     if n>0 :           # si il y a des voisins minés
    193.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    194.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    195.  
    196.  
    197. # == créer le terrain de jeu ==
    198. def creerleterrain() :
    199.     global terrain
    200.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    201.         terrain.append([])                      # ajouter une ligne au tableau
    202.         for c in range (0,maxc) :               # boucle sur chaque colonne
    203.             terrain[l].append(COUVERTE)         # créer la case
    204.  
    205. # == créer les mines ==
    206. def poserlesmines() :
    207.     global mines,NBREMINES
    208.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    209.         mines.append([])                        # ajouter une ligne au tableau
    210.         for c in range (0,maxc) :               # boucle sur chaque colonne
    211.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    212.                 mines[l].append(True)           # cocher la case
    213.                 NBREMINES+=1                    # compter les mines
    214.             else :                              # sinon
    215.                 mines[l].append(False)          # ne pas cocher
    216.  
    217. # ==  découvrir une case ==
    218. def decouvrir(l,c) :
    219.     global terrain,NBREDECOUVERTES
    220.     if terrain[l][c]!=DECOUVERTE : # si la case n'est pas déjà découverte
    221.         NBREDECOUVERTES+=1         # en compter une de plus
    222.     terrain[l][c]=DECOUVERTE
    223.     if mines[l][c]!=True : # la cellule n'est pas minée
    224.         # lancement de l'exploration récursive
    225.         minCol=minLigne=-1 # bornes mini pour les voisins
    226.         maxCol=maxLigne=2  # bornes maxi pour les voisins
    227.         if voisins(l,c)=="" : # si aucun voisin ne contient de mine, lancer l'exploration
    228.             if c<1 : minCol=0            # réglage fin de la borne min en horizontal
    229.             if c>=maxc-1 : maxCol=1   # réglage fin de la borne max en horizontal
    230.             if l<1 : minLigne=0          # réglage fin de la borne min en vertical
    231.             if l>=maxl-1 : maxLigne=1 # réglage fin de la borne max en vertical
    232.             # explorer tous les voisins
    233.             for x in range(minCol,maxCol) :
    234.                 for y in range(minLigne,maxLigne) :
    235.                     if (x!=0)or(y!=0) : # sauf la cellule elle-même
    236.                         if terrain[y+l][x+c]==COUVERTE : # si la case n'a pas encore été explorée
    237.                             decouvrir(y+l,x+c)           # la découvrir (marcher dessus)
    238.  
    239. # ==  découvrir une case ==
    240. def changermarque(l,c) :
    241.     global terrain,NBREMARQUES
    242.     if terrain[l][c]==COUVERTE :
    243.         terrain[l][c]=MARQUEE
    244.         NBREMARQUES+=1
    245.     elif  terrain[l][c]==MARQUEE :
    246.         terrain[l][c]=COUVERTE
    247.         NBREMARQUES-=1
    248.  
    249. # ==  afficher le curseur ==
    250. def affichecurseur(l,c) :
    251.     c0=c*ecarth     # colonne gauche
    252.     l0=l*ecartv     # ligne haut
    253.     c1=c0+ecarth    # colonne droite
    254.     l1=l0+ecartv    # ligne bas
    255.     # les coins
    256.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    257.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    258.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    259.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    260.     # les 2 bords horizontaux
    261.     for cc in range(c0+1,c1) :
    262.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    263.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    264.     # les 2 bords verticaux
    265.     for ll in range(l0+1,l1) :
    266.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    267.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    268.    
    269. ############################################
    270. #  C O R P S     D U    P R O G R A M M E
    271. ############################################
    272. curses.noecho()         # pas d'affichage de la frappe clavier
    273. curses.curs_set(False)  # pas d'affichage du curseur
    274. ecran.nodelay(1)        # pour le chronomètre qui doit s'afficher en continu, même si on ne fait rien
    275. poserlesmines()                               # créer les marques
    276. creerleterrain()                              # créer les marques
    277. ligne=1                                       # position verticale initiale du curseur
    278. colonne=1                                     # position horizontale initiale du curseur
    279. unetouche=0                                   # pour pouvoir entrer dans la boucle
    280. while unetouche!=quitter and PERDU==False :   # tant pas touche Q ni perdu...
    281.     # analyse de la frappe clavier
    282.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    283.         colonne += 1
    284.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    285.         colonne -= 1
    286.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    287.         ligne -= 1
    288.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    289.         ligne += 1
    290.     elif unetouche==marcher :                               # découvrir
    291.         decouvrir(ligne,colonne)
    292.         if mines[ligne][colonne] :
    293.             PERDU=True
    294.     elif unetouche==marquer :                               # marquer/démarquer
    295.         changermarque(ligne,colonne)
    296.     # (ré-)affichage du terrain
    297.     affichagegrille()                                       # la grille
    298.     affichecurseur(ligne,colonne)                           # le curseur
    299.     infos()                                                 # informations sur le jeu en cours
    300.     # attente...
    301.     if PERDU==False :
    302.         unetouche=ecran.getch()                             # attente d'une frappe clavier
    303.  
    304. ############################################
    305. #  C ' E S T    P E R D U
    306. ############################################
    307. if PERDU :
    308.     ecran.addstr(1+maxl*ecartv,2,"                      ",TRAITPERDU)
    309.     ecran.addstr(2+maxl*ecartv,2,"  Vous avez perdu...  ",TRAITPERDU)
    310.     ecran.addstr(3+maxl*ecartv,2,"                      ",TRAITPERDU)
    311.     ecran.getch()                                           # attente d'une frappe clavier
    312.  
    313. ############################################
    314. #  F I N
    315. ############################################
    316. curses.endwin()  # revenir à la console
  • Le programme doit détecter quand on a gagné. Et il doit s'arrêter.
    demineur012.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##    D O U Z 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,time
    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. TPSDEBUT=time.time()      #  Top départ, pour le calcul du temps passé
    21.  
    22. ############################################
    23. #  P A R A M È T R E S
    24. ############################################
    25. maxl=8                # nombre de lignes dans la grille
    26. maxc=14               # nombre de colonnes dans la grille
    27. ecarth=4              # écart entre deux lignes horizontales
    28. ecartv=3              # écart entre deux lignes verticales
    29. marcher=ord(" ")      # touche pour découvrir une cellule (marcher dessus)
    30. marquer=ord("*")      # touche pour marquer/démarquer une cellule
    31. quitter=ord("q")      # touche pour quitter
    32. terrain=[]            # création du terrain de jeu vide
    33. mines=[]              # création du tableau des mines vide
    34. probamarques=0.1      # probabilité d'apparition des marques
    35. COUVERTE=0            # état original des cases
    36. DECOUVERTE=1          # case découverte
    37. MARQUEE=2             # case marquée
    38. DESSINMINE="XXX"      # représentation d'une mine à l'écran
    39. PERDU=False           # passe à True quand on découvre une mine, ce qui provoque l'arrêt du programme
    40. NBREMARQUES=0         # nombre de marques posées sur le terrain
    41. NBREMINES=0           # nombre de mines
    42. NBREDECOUVERTES=0     # nombre de cases découvertes
    43. ############################################
    44. # Pour les couleurs
    45. ############################################
    46. curses.start_color()
    47.  
    48. #  Jeu de couleurs pour le curseur
    49. COULEURCURSEUR=1
    50. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    51. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    52.  
    53. #  Jeu de couleurs pour la grille
    54. COULEURGRILLE=2
    55. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    56. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    57.  
    58. #  Jeu de couleurs pour une case couverte
    59. COULEURCOUVERTE=3
    60. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    61. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    62.  
    63. #  Jeu de couleurs pour une case découverte
    64. COULEURDECOUVERTE=4
    65. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    66. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    67.  
    68. #  Jeu de couleurs pour une case marquée
    69. COULEURMARQUE=5
    70. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    71. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    72.  
    73. #  Jeu de couleurs pour le texte en cas de mine explosée
    74. COULEURPERDU=6
    75. curses.init_pair(COULEURPERDU,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    76. TRAITPERDU=curses.color_pair(COULEURPERDU)+curses.A_BOLD+curses.A_BLINK
    77.  
    78. #  Jeu de couleurs pour le texte d'information
    79. COULEURINFOS=7
    80. curses.init_pair(COULEURINFOS,curses.COLOR_WHITE,curses.COLOR_BLACK)
    81. TRAITINFOS=curses.color_pair(COULEURINFOS)
    82.  
    83. #  Jeu de couleurs pour la sortie prématurée
    84. COULEURSORTIE=8
    85. curses.init_pair(COULEURSORTIE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    86. TRAITSORTIE=curses.color_pair(COULEURSORTIE)+curses.A_BOLD
    87.  
    88. #  Jeu de couleurs pour la partie gagnée
    89. COULEURGAGNE=9
    90. curses.init_pair(COULEURGAGNE,curses.COLOR_RED,curses.COLOR_WHITE)
    91. TRAITGAGNE=curses.color_pair(COULEURGAGNE)+curses.A_BOLD
    92.  
    93. ############################################
    94. # Définition des caractères des cadres
    95. ############################################
    96. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    97. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    98. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    99. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    100. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    101. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    102. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    103. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    104. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    105. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    106. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    107.  
    108. ############################################
    109. #  F O N C T I O N S
    110. ############################################
    111. # ==  teste si on a gagné  ==
    112. def gagne() : # renvoie True quand on a tout trouvé, ce qui provoque l'arrêt du programme
    113.     for l in range(0,maxl) :                # pour chaque ligne
    114.         for c in range(0,maxc) :     # pour chaque colonne
    115.             if (terrain[l][c]==MARQUEE) != mines[l][c] :
    116.                 return False
    117.     return True
    118.  
    119. # == affichage des informations sur le jeu en cours ==
    120. def infos() :
    121.     l,c=2,maxc*ecarth+2
    122.     ecran.addstr(l  ,c,"Infos",TRAITINFOS+curses.A_BOLD)
    123.     ecran.addstr(l+1,c,"      Nombre de cases :  "+str(maxc*maxl),TRAITINFOS)
    124.     ecran.addstr(l+2,c,"Nombre de découvertes :  "+str(NBREDECOUVERTES),TRAITINFOS)
    125.     ecran.addstr(l+3,c,"    Nombre de marques :  "+str(NBREMARQUES),TRAITINFOS)
    126.     ecran.addstr(l+4,c,"      Nombre de mines :  "+str(NBREMINES),TRAITINFOS)
    127.     ecran.addstr(l+5,c,"     Temps écoulé (s) : ")
    128.     ecran.addstr(l+5,c+25,str(int(time.time()-TPSDEBUT)))
    129.  
    130. # == affichage de la grille ==
    131. def affichagegrille() :
    132.     # création des lignes verticales
    133.     for c in range(0,maxc+1) :                   # pour chaque ligne
    134.         for l in range(1,ecartv*maxl) :          # pour chaque case
    135.             # afficher un trait vertical
    136.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    137.     # création des lignes horizontales
    138.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    139.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    140.             if l==0 and c==0 :
    141.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    142.             elif l==0 and c == ecarth*maxc :
    143.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    144.             elif l==0 and c % ecarth == 0 :
    145.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    146.             elif l==maxl and c==0 :
    147.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    148.             elif l==maxl and c == ecarth*maxc :
    149.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    150.             elif l==maxl and c % ecarth == 0 :
    151.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    152.             elif c==0 :
    153.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    154.             elif c==ecarth*maxc :
    155.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    156.             elif c % ecarth == 0 :
    157.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    158.             else :
    159.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    160.     # affichage du contenu
    161.     for l in range(0,maxl) :                # pour chaque ligne
    162.         for c in range(0,maxc) :            # pour chaque colonne
    163.             l0=l*ecartv+1
    164.             c0=c*ecarth+1
    165.             if terrain[l][c]==MARQUEE :
    166.                 couleur=TRAITMARQUE         # couleur pour une marque
    167.                 remplir="X"                 # dessin pour une marque
    168.             elif terrain[l][c]==COUVERTE :
    169.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    170.                 remplir=" "                 # dessin pour case non découverte
    171.             else :
    172.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    173.                 remplir=" "                 # dessin pour case découverte
    174.             for ll in range(0,ecartv-1) :   # dessin de la case
    175.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    176.             if terrain[l][c]==DECOUVERTE :
    177.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    178.             if PERDU: # si perdu on affiche toutes les mines
    179.                 if mines[l][c] :
    180.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    181.  
    182. # == compter les voisins d'une case ==
    183. def voisins( lig , col ) :
    184.     # détermination des limites d'exploration
    185.     if lig==0 :      # si trop haut
    186.         l0=lig       # commencer sur cette ligne
    187.     else :           # sinon
    188.         l0=lig-1     # commencer à la ligne du dessus
    189.     if lig==maxl-1 : # si trop haut
    190.         l1=lig       # finir sur cette ligne
    191.     else :           # sinon
    192.         l1=lig+1     # finir sur la ligne du dessous
    193.     if col==0 :      # si trop à gauche
    194.         c0=col       # commencer sur cette colonne
    195.     else :           # sinon
    196.         c0=col-1     # commencer sur la colonne précédente
    197.     if col==maxc-1 : # si trop à droite
    198.         c1=col       # commencer sur cette colonne
    199.     else :           # sinon
    200.         c1=col+1     # commencer sur la colonne suivante
    201.     # exploration des cases voisines
    202.     n=0                             # initialisation du compteur
    203.     for l in range (l0,l1+1) :      # pour toutes les lignes
    204.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    205.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    206.                 if mines[l][c] :    # et que la case est minée
    207.                     n += 1          # incrémenter le compteur
    208.     # renvoyer les résultats
    209.     if n>0 :           # si il y a des voisins minés
    210.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    211.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    212.  
    213.  
    214. # == créer le terrain de jeu ==
    215. def creerleterrain() :
    216.     global terrain
    217.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    218.         terrain.append([])                      # ajouter une ligne au tableau
    219.         for c in range (0,maxc) :               # boucle sur chaque colonne
    220.             terrain[l].append(COUVERTE)         # créer la case
    221.  
    222. # == créer les mines ==
    223. def poserlesmines() :
    224.     global mines,NBREMINES
    225.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    226.         mines.append([])                        # ajouter une ligne au tableau
    227.         for c in range (0,maxc) :               # boucle sur chaque colonne
    228.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    229.                 mines[l].append(True)           # cocher la case
    230.                 NBREMINES+=1                    # compter les mines
    231.             else :                              # sinon
    232.                 mines[l].append(False)          # ne pas cocher
    233.  
    234. # ==  découvrir une case ==
    235. def decouvrir(l,c) :
    236.     global terrain,NBREDECOUVERTES
    237.     if terrain[l][c]!=DECOUVERTE : # si la case n'est pas déjà découverte
    238.         NBREDECOUVERTES+=1         # en compter une de plus
    239.     terrain[l][c]=DECOUVERTE
    240.     if mines[l][c]!=True : # la cellule n'est pas minée
    241.         # lancement de l'exploration récursive
    242.         minCol=minLigne=-1 # bornes mini pour les voisins
    243.         maxCol=maxLigne=2  # bornes maxi pour les voisins
    244.         if voisins(l,c)=="" : # si aucun voisin ne contient de mine, lancer l'exploration
    245.             if c<1 : minCol=0            # réglage fin de la borne min en horizontal
    246.             if c>=maxc-1 : maxCol=1   # réglage fin de la borne max en horizontal
    247.             if l<1 : minLigne=0          # réglage fin de la borne min en vertical
    248.             if l>=maxl-1 : maxLigne=1 # réglage fin de la borne max en vertical
    249.             # explorer tous les voisins
    250.             for x in range(minCol,maxCol) :
    251.                 for y in range(minLigne,maxLigne) :
    252.                     if (x!=0)or(y!=0) : # sauf la cellule elle-même
    253.                         if terrain[y+l][x+c]==COUVERTE : # si la case n'a pas encore été explorée
    254.                             decouvrir(y+l,x+c)           # la découvrir (marcher dessus)
    255.  
    256. # ==  découvrir une case ==
    257. def changermarque(l,c) :
    258.     global terrain,NBREMARQUES
    259.     if terrain[l][c]==COUVERTE :
    260.         terrain[l][c]=MARQUEE
    261.         NBREMARQUES+=1
    262.     elif  terrain[l][c]==MARQUEE :
    263.         terrain[l][c]=COUVERTE
    264.         NBREMARQUES-=1
    265.  
    266. # ==  afficher le curseur ==
    267. def affichecurseur(l,c) :
    268.     c0=c*ecarth     # colonne gauche
    269.     l0=l*ecartv     # ligne haut
    270.     c1=c0+ecarth    # colonne droite
    271.     l1=l0+ecartv    # ligne bas
    272.     # les coins
    273.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    274.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    275.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    276.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    277.     # les 2 bords horizontaux
    278.     for cc in range(c0+1,c1) :
    279.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    280.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    281.     # les 2 bords verticaux
    282.     for ll in range(l0+1,l1) :
    283.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    284.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    285.    
    286. ############################################
    287. #  C O R P S     D U    P R O G R A M M E
    288. ############################################
    289. curses.noecho()         # pas d'affichage de la frappe clavier
    290. curses.curs_set(False)  # pas d'affichage du curseur
    291. ecran.nodelay(1)        # pour le chronomètre qui doit s'afficher en continu, même si on ne fait rien
    292. poserlesmines()                               # créer les marques
    293. creerleterrain()                              # créer les marques
    294. ligne=1                                       # position verticale initiale du curseur
    295. colonne=1                                     # position horizontale initiale du curseur
    296. unetouche=0                                   # pour pouvoir entrer dans la boucle
    297. while unetouche!=quitter and PERDU==False and gagne()==False : # tant pas fini...
    298.     # analyse de la frappe clavier
    299.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    300.         colonne += 1
    301.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    302.         colonne -= 1
    303.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    304.         ligne -= 1
    305.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    306.         ligne += 1
    307.     elif unetouche==marcher :                               # découvrir
    308.         decouvrir(ligne,colonne)
    309.         if mines[ligne][colonne] :
    310.             PERDU=True
    311.     elif unetouche==marquer :                               # marquer/démarquer
    312.         changermarque(ligne,colonne)
    313.     # (ré-)affichage du terrain
    314.     affichagegrille()                                       # la grille
    315.     affichecurseur(ligne,colonne)                           # le curseur
    316.     infos()                                                 # informations sur le jeu en cours
    317.     # attente...
    318.     if PERDU==False :
    319.         unetouche=ecran.getch()                             # attente d'une frappe clavier
    320.  
    321. ############################################
    322. #   L A    P A R T I E    E S T    F I N I E
    323. ############################################
    324. ecran.nodelay(0)  
    325. if PERDU :
    326.     ecran.addstr(1+maxl*ecartv,2,"                      ",TRAITPERDU)
    327.     ecran.addstr(2+maxl*ecartv,2,"  Vous avez perdu...  ",TRAITPERDU)
    328.     ecran.addstr(3+maxl*ecartv,2,"                      ",TRAITPERDU)
    329. elif unetouche==quitter :
    330.     ecran.addstr(1+maxl*ecartv,2,"Vous avez demandé à arrêter",TRAITSORTIE)
    331.     ecran.addstr(2+maxl*ecartv,2,"Dommage...  ",TRAITSORTIE)
    332. else :
    333.     ecran.addstr(1+maxl*ecartv,2,"Bravo vous avez gagné.",TRAITGAGNE)
    334.     ecran.addstr(2+maxl*ecartv,2,"Vous avez tout trouvé en "+str(int(time.time()-TPSDEBUT))+" secondes.",TRAITGAGNE)
    335.  
    336. ecran.getch()          # attente d'une frappe clavier
    337.  
    338. ############################################
    339. #  F I N
    340. ############################################
    341. curses.endwin()  # revenir à la console
  • Ajoutez un écran d'aide qui s'affiche quand on appuie sur « a » ou « A » ou « h » ou « H », et qui s'efface quand on appuie sur une touche quelconque.
    demineur013.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##  T R E I Z 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,time
    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. TPSDEBUT=time.time()      #  Top départ, pour le calcul du temps passé
    21.  
    22. ############################################
    23. #  P A R A M È T R E S
    24. ############################################
    25. maxl=8                # nombre de lignes dans la grille
    26. maxc=14               # nombre de colonnes dans la grille
    27. ecarth=4              # écart entre deux lignes horizontales
    28. ecartv=3              # écart entre deux lignes verticales
    29. marcher=ord(" ")      # touche pour découvrir une cellule (marcher dessus)
    30. marquer=ord("*")      # touche pour marquer/démarquer une cellule
    31. quitter=ord("q")      # touche pour quitter
    32. terrain=[]            # création du terrain de jeu vide
    33. mines=[]              # création du tableau des mines vide
    34. probamarques=0.1      # probabilité d'apparition des marques
    35. COUVERTE=0            # état original des cases
    36. DECOUVERTE=1          # case découverte
    37. MARQUEE=2             # case marquée
    38. DESSINMINE="XXX"      # représentation d'une mine à l'écran
    39. PERDU=False           # passe à True quand on découvre une mine, ce qui provoque l'arrêt du programme
    40. NBREMARQUES=0         # nombre de marques posées sur le terrain
    41. NBREMINES=0           # nombre de mines
    42. NBREDECOUVERTES=0     # nombre de cases découvertes
    43. AIDES=[ord('a'),ord('A'),ord('h'),ord('H') ] # touches pour l'écran d'aide
    44. ############################################
    45. # Pour les couleurs
    46. ############################################
    47. curses.start_color()
    48.  
    49. #  Jeu de couleurs pour le curseur
    50. COULEURCURSEUR=1
    51. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    52. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    53.  
    54. #  Jeu de couleurs pour la grille
    55. COULEURGRILLE=2
    56. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    57. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    58.  
    59. #  Jeu de couleurs pour une case couverte
    60. COULEURCOUVERTE=3
    61. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    62. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    63.  
    64. #  Jeu de couleurs pour une case découverte
    65. COULEURDECOUVERTE=4
    66. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    67. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    68.  
    69. #  Jeu de couleurs pour une case marquée
    70. COULEURMARQUE=5
    71. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    72. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    73.  
    74. #  Jeu de couleurs pour le texte en cas de mine explosée
    75. COULEURPERDU=6
    76. curses.init_pair(COULEURPERDU,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    77. TRAITPERDU=curses.color_pair(COULEURPERDU)+curses.A_BOLD+curses.A_BLINK
    78.  
    79. #  Jeu de couleurs pour le texte d'information
    80. COULEURINFOS=7
    81. curses.init_pair(COULEURINFOS,curses.COLOR_WHITE,curses.COLOR_BLACK)
    82. TRAITINFOS=curses.color_pair(COULEURINFOS)
    83.  
    84. #  Jeu de couleurs pour la sortie prématurée
    85. COULEURSORTIE=8
    86. curses.init_pair(COULEURSORTIE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    87. TRAITSORTIE=curses.color_pair(COULEURSORTIE)+curses.A_BOLD
    88.  
    89. #  Jeu de couleurs pour la partie gagnée
    90. COULEURGAGNE=9
    91. curses.init_pair(COULEURGAGNE,curses.COLOR_RED,curses.COLOR_WHITE)
    92. TRAITGAGNE=curses.color_pair(COULEURGAGNE)+curses.A_BOLD
    93.  
    94. ############################################
    95. # Définition des caractères des cadres
    96. ############################################
    97. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    98. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    99. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    100. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    101. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    102. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    103. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    104. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    105. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    106. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    107. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    108.  
    109. ############################################
    110. #  F O N C T I O N S
    111. ############################################
    112. # == affichage de l'aide ==
    113. def aide() :
    114.     ecran.clear()
    115.     ecran.nodelay(0)
    116.     ecran.addstr(1,8,"  Aide  \n\n",curses.A_BOLD+curses.A_REVERSE)
    117.     ecran.addch(curses.ACS_DIAMOND)
    118.     ecran.addstr(" H ou h ou A ou a  : cette page d'aide\n")
    119.     ecran.addch(curses.ACS_DIAMOND)
    120.     ecran.addstr(" Flèches (")
    121.     ecran.addch(curses.ACS_LARROW)
    122.     ecran.addstr(" ")
    123.     ecran.addch(curses.ACS_RARROW)
    124.     ecran.addstr(" ")
    125.     ecran.addch(curses.ACS_UARROW)
    126.     ecran.addstr(" ")
    127.     ecran.addch(curses.ACS_DARROW)
    128.     ecran.addstr(")  : Déplacement\n")
    129.     ecran.addch(curses.ACS_DIAMOND)
    130.     ecran.addstr(" * : marquer une cellule\n")
    131.     ecran.addch(curses.ACS_DIAMOND)
    132.     ecran.addstr(" <espace>  : explorer (marcher sur) une cellule\n")
    133.     ecran.addch(curses.ACS_DIAMOND)
    134.     ecran.addstr(" Q ou q  : quitter le jeu\n\nAppuyer sur n'importe quelle touche pour continuer à jouer.")
    135.     ecran.getch()
    136.     ecran.clear()
    137.     ecran.nodelay(1)
    138.  
    139. # == teste si on a gagné ==
    140. def gagne() : # renvoie True quand on a tout trouvé, ce qui provoque l'arrêt du programme
    141.     for l in range(0,maxl) :                # pour chaque ligne
    142.         for c in range(0,maxc) :     # pour chaque colonne
    143.             if (terrain[l][c]==MARQUEE) != mines[l][c] :
    144.                 return False
    145.     return True
    146.  
    147. # == affichage des informations sur le jeu en cours ==
    148. def infos() :
    149.     l,c=2,maxc*ecarth+2
    150.     ecran.addstr(l  ,c,"Infos",TRAITINFOS+curses.A_BOLD)
    151.     ecran.addstr(l+1,c,"      Nombre de cases :  "+str(maxc*maxl),TRAITINFOS)
    152.     ecran.addstr(l+2,c,"Nombre de découvertes :  "+str(NBREDECOUVERTES),TRAITINFOS)
    153.     ecran.addstr(l+3,c,"    Nombre de marques :  "+str(NBREMARQUES),TRAITINFOS)
    154.     ecran.addstr(l+4,c,"      Nombre de mines :  "+str(NBREMINES),TRAITINFOS)
    155.     ecran.addstr(l+5,c,"     Temps écoulé (s) : ")
    156.     ecran.addstr(l+5,c+25,str(int(time.time()-TPSDEBUT)))
    157.  
    158. # == affichage de la grille ==
    159. def affichagegrille() :
    160.     # création des lignes verticales
    161.     for c in range(0,maxc+1) :                   # pour chaque ligne
    162.         for l in range(1,ecartv*maxl) :          # pour chaque case
    163.             # afficher un trait vertical
    164.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    165.     # création des lignes horizontales
    166.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    167.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    168.             if l==0 and c==0 :
    169.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    170.             elif l==0 and c == ecarth*maxc :
    171.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    172.             elif l==0 and c % ecarth == 0 :
    173.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    174.             elif l==maxl and c==0 :
    175.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    176.             elif l==maxl and c == ecarth*maxc :
    177.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    178.             elif l==maxl and c % ecarth == 0 :
    179.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    180.             elif c==0 :
    181.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    182.             elif c==ecarth*maxc :
    183.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    184.             elif c % ecarth == 0 :
    185.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    186.             else :
    187.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    188.     # affichage du contenu
    189.     for l in range(0,maxl) :                # pour chaque ligne
    190.         for c in range(0,maxc) :            # pour chaque colonne
    191.             l0=l*ecartv+1
    192.             c0=c*ecarth+1
    193.             if terrain[l][c]==MARQUEE :
    194.                 couleur=TRAITMARQUE         # couleur pour une marque
    195.                 remplir="X"                 # dessin pour une marque
    196.             elif terrain[l][c]==COUVERTE :
    197.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    198.                 remplir=" "                 # dessin pour case non découverte
    199.             else :
    200.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    201.                 remplir=" "                 # dessin pour case découverte
    202.             for ll in range(0,ecartv-1) :   # dessin de la case
    203.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    204.             if terrain[l][c]==DECOUVERTE :
    205.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    206.             if PERDU: # si perdu on affiche toutes les mines
    207.                 if mines[l][c] :
    208.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    209.  
    210. # == compter les voisins d'une case ==
    211. def voisins( lig , col ) :
    212.     # détermination des limites d'exploration
    213.     if lig==0 :      # si trop haut
    214.         l0=lig       # commencer sur cette ligne
    215.     else :           # sinon
    216.         l0=lig-1     # commencer à la ligne du dessus
    217.     if lig==maxl-1 : # si trop haut
    218.         l1=lig       # finir sur cette ligne
    219.     else :           # sinon
    220.         l1=lig+1     # finir sur la ligne du dessous
    221.     if col==0 :      # si trop à gauche
    222.         c0=col       # commencer sur cette colonne
    223.     else :           # sinon
    224.         c0=col-1     # commencer sur la colonne précédente
    225.     if col==maxc-1 : # si trop à droite
    226.         c1=col       # commencer sur cette colonne
    227.     else :           # sinon
    228.         c1=col+1     # commencer sur la colonne suivante
    229.     # exploration des cases voisines
    230.     n=0                             # initialisation du compteur
    231.     for l in range (l0,l1+1) :      # pour toutes les lignes
    232.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    233.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    234.                 if mines[l][c] :    # et que la case est minée
    235.                     n += 1          # incrémenter le compteur
    236.     # renvoyer les résultats
    237.     if n>0 :           # si il y a des voisins minés
    238.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    239.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    240.  
    241.  
    242. # == créer le terrain de jeu ==
    243. def creerleterrain() :
    244.     global terrain
    245.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    246.         terrain.append([])                      # ajouter une ligne au tableau
    247.         for c in range (0,maxc) :               # boucle sur chaque colonne
    248.             terrain[l].append(COUVERTE)         # créer la case
    249.  
    250. # == créer les mines ==
    251. def poserlesmines() :
    252.     global mines,NBREMINES
    253.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    254.         mines.append([])                        # ajouter une ligne au tableau
    255.         for c in range (0,maxc) :               # boucle sur chaque colonne
    256.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    257.                 mines[l].append(True)           # cocher la case
    258.                 NBREMINES+=1                    # compter les mines
    259.             else :                              # sinon
    260.                 mines[l].append(False)          # ne pas cocher
    261.  
    262. # ==  découvrir une case ==
    263. def decouvrir(l,c) :
    264.     global terrain,NBREDECOUVERTES
    265.     if terrain[l][c]!=DECOUVERTE : # si la case n'est pas déjà découverte
    266.         NBREDECOUVERTES+=1         # en compter une de plus
    267.     terrain[l][c]=DECOUVERTE
    268.     if mines[l][c]!=True : # la cellule n'est pas minée
    269.         # lancement de l'exploration récursive
    270.         minCol=minLigne=-1 # bornes mini pour les voisins
    271.         maxCol=maxLigne=2  # bornes maxi pour les voisins
    272.         if voisins(l,c)=="" : # si aucun voisin ne contient de mine, lancer l'exploration
    273.             if c<1 : minCol=0            # réglage fin de la borne min en horizontal
    274.             if c>=maxc-1 : maxCol=1   # réglage fin de la borne max en horizontal
    275.             if l<1 : minLigne=0          # réglage fin de la borne min en vertical
    276.             if l>=maxl-1 : maxLigne=1 # réglage fin de la borne max en vertical
    277.             # explorer tous les voisins
    278.             for x in range(minCol,maxCol) :
    279.                 for y in range(minLigne,maxLigne) :
    280.                     if (x!=0)or(y!=0) : # sauf la cellule elle-même
    281.                         if terrain[y+l][x+c]==COUVERTE : # si la case n'a pas encore été explorée
    282.                             decouvrir(y+l,x+c)           # la découvrir (marcher dessus)
    283.  
    284. # ==  découvrir une case ==
    285. def changermarque(l,c) :
    286.     global terrain,NBREMARQUES
    287.     if terrain[l][c]==COUVERTE :
    288.         terrain[l][c]=MARQUEE
    289.         NBREMARQUES+=1
    290.     elif  terrain[l][c]==MARQUEE :
    291.         terrain[l][c]=COUVERTE
    292.         NBREMARQUES-=1
    293.  
    294. # ==  afficher le curseur ==
    295. def affichecurseur(l,c) :
    296.     c0=c*ecarth     # colonne gauche
    297.     l0=l*ecartv     # ligne haut
    298.     c1=c0+ecarth    # colonne droite
    299.     l1=l0+ecartv    # ligne bas
    300.     # les coins
    301.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    302.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    303.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    304.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    305.     # les 2 bords horizontaux
    306.     for cc in range(c0+1,c1) :
    307.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    308.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    309.     # les 2 bords verticaux
    310.     for ll in range(l0+1,l1) :
    311.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    312.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    313.    
    314. ############################################
    315. #  C O R P S     D U    P R O G R A M M E
    316. ############################################
    317. curses.noecho()         # pas d'affichage de la frappe clavier
    318. curses.curs_set(False)  # pas d'affichage du curseur
    319. ecran.nodelay(1)        # pour le chronomètre qui doit s'afficher en continu, même si on ne fait rien
    320. poserlesmines()                               # créer les marques
    321. creerleterrain()                              # créer les marques
    322. ligne=1                                       # position verticale initiale du curseur
    323. colonne=1                                     # position horizontale initiale du curseur
    324. unetouche=0                                   # pour pouvoir entrer dans la boucle
    325. while unetouche!=quitter and PERDU==False and gagne()==False : # tant pas fini...
    326.     # analyse de la frappe clavier
    327.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    328.         colonne += 1
    329.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    330.         colonne -= 1
    331.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    332.         ligne -= 1
    333.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    334.         ligne += 1
    335.     elif unetouche==marcher :                               # découvrir
    336.         decouvrir(ligne,colonne)
    337.         if mines[ligne][colonne] :
    338.             PERDU=True
    339.     elif unetouche==marquer :                               # marquer/démarquer
    340.         changermarque(ligne,colonne)
    341.     elif unetouche in AIDES :                               # écran d'aide
    342.         aide()
    343.     # (ré-)affichage du terrain
    344.     affichagegrille()                                       # la grille
    345.     affichecurseur(ligne,colonne)                           # le curseur
    346.     infos()                                                 # informations sur le jeu en cours
    347.     # attente...
    348.     if PERDU==False :
    349.         unetouche=ecran.getch()                             # attente d'une frappe clavier
    350.  
    351. ############################################
    352. #   L A    P A R T I E    E S T    F I N I E
    353. ############################################
    354. ecran.nodelay(0)  
    355. if PERDU :
    356.     ecran.addstr(1+maxl*ecartv,2,"                      ",TRAITPERDU)
    357.     ecran.addstr(2+maxl*ecartv,2,"  Vous avez perdu...  ",TRAITPERDU)
    358.     ecran.addstr(3+maxl*ecartv,2,"                      ",TRAITPERDU)
    359. elif unetouche==quitter :
    360.     ecran.addstr(1+maxl*ecartv,2,"Vous avez demandé à arrêter",TRAITSORTIE)
    361.     ecran.addstr(2+maxl*ecartv,2,"Dommage...  ",TRAITSORTIE)
    362. else :
    363.     ecran.addstr(1+maxl*ecartv,2,"Bravo vous avez gagné.",TRAITGAGNE)
    364.     ecran.addstr(2+maxl*ecartv,2,"Vous avez tout trouvé en "+str(int(time.time()-TPSDEBUT))+" secondes.",TRAITGAGNE)
    365.  
    366. ecran.getch()          # attente d'une frappe clavier
    367.  
    368. ############################################
    369. #  F I N
    370. ############################################
    371. curses.endwin()  # revenir à la console
Dernière modification : 25/8/2016
Dernière modification : 25/8/2016