Déroulement réel des cours

La « pensée » du mercredi 21 août 2019, 21h52m09s :
Les dieux ont donné le feu aux hommes et ils ont inventé les voitures de pompier. Ils leur ont donné l'amour et ils ont inventé le mariage.
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) :
  1. Corrigé pour la fois dernière :
    • créer les listes terrain[] et mines[],
    • remplir les listes terrain[] et mines[],
    • affichage propre.
    demineur004.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##   Q U A T R 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. terrain=[]          # création du terrain de jeu vide
    29. mines=[]            # création du tableau des mines vide
    30. quitter=ord("q")    # touche pour quitter
    31. probamarques=0.2    # probabilité d'apparition des marques
    32. COUVERTE=0          # état original des cases
    33. DECOUVERTE=1        # case découverte
    34. MARQUEE=2           # case marquée
    35.  
    36. ############################################
    37. # Pour les couleurs
    38. ############################################
    39. curses.start_color()
    40.  
    41. #  Jeu de couleurs pour le curseur
    42. COULEURCURSEUR=1
    43. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    44. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    45.  
    46. #  Jeu de couleurs pour la grille
    47. COULEURGRILLE=2
    48. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    49. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    50.  
    51. ############################################
    52. # Définition des caractères des cadres
    53. ############################################
    54. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    55. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    56. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    57. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    58. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    59. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    60. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    61. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    62. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    63. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    64. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    65.  
    66. ############################################
    67. #  F O N C T I O N S
    68. ############################################
    69. # == affichage de la grille ==
    70. def affichagegrille() :
    71.     # création des lignes verticales
    72.     for c in range(0,maxc+1) :                   # pour chaque ligne
    73.         for l in range(1,ecartv*maxl) :          # pour chaque case
    74.             # afficher un trait vertical
    75.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    76.     # création des lignes horizontales
    77.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    78.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    79.             if l==0 and c==0 :
    80.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    81.             elif l==0 and c == ecarth*maxc :
    82.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    83.             elif l==0 and c % ecarth == 0 :
    84.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    85.             elif l==maxl and c==0 :
    86.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    87.             elif l==maxl and c == ecarth*maxc :
    88.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    89.             elif l==maxl and c % ecarth == 0 :
    90.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    91.             elif c==0 :
    92.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    93.             elif c==ecarth*maxc :
    94.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    95.             elif c % ecarth == 0 :
    96.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    97.             else :
    98.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    99.  
    100. # == créer le terrain de jeu ==
    101. def creerleterrain() :
    102.     global terrain
    103.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    104.         terrain.append([])                      # ajouter une ligne au tableau
    105.         for c in range (0,maxc) :               # boucle sur chaque colonne
    106.             terrain[l].append(COUVERTE)         # créer la case
    107.  
    108. # == créer les mines ==
    109. def poserlesmines() :
    110.     global mines
    111.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    112.         mines.append([])                        # ajouter une ligne au tableau
    113.         for c in range (0,maxc) :               # boucle sur chaque colonne
    114.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    115.                 mines[l].append(True)           # cocher la case
    116.             else :                              # sinon
    117.                 mines[l].append(False)          # ne pas cocher
    118.  
    119. # ==  afficher le curseur ==
    120. def affichecurseur(l,c) :
    121.     c0=c*ecarth     # colonne gauche
    122.     l0=l*ecartv     # ligne haut
    123.     c1=c0+ecarth    # colonne droite
    124.     l1=l0+ecartv    # ligne bas
    125.     # les coins
    126.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    127.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    128.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    129.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    130.     # les 2 bords horizontaux
    131.     for cc in range(c0+1,c1) :
    132.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    133.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    134.     # les 2 bords verticaux
    135.     for ll in range(l0+1,l1) :
    136.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    137.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    138.    
    139. ############################################
    140. #  C O R P S     D U    P R O G R A M M E
    141. ############################################
    142. poserlesmines()              # créer les marques
    143. creerleterrain()             # créer les marques
    144. ligne=1                      # position verticale initiale du curseur
    145. colonne=1                    # position horizontale initiale du curseur
    146. unetouche=0                  # pour pouvoir entrer dans la boucle
    147. while unetouche!=quitter :   # tant qu'on n'a pas appuyé sur la touche Q
    148.     # analyse de la frappe clavier
    149.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    150.         colonne += 1
    151.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    152.         colonne -= 1
    153.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    154.         ligne -= 1
    155.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    156.         ligne += 1
    157.     # (ré-)affichage du terrain
    158.     ecran.clear()                   # effacer l'écran
    159.     affichagegrille()               # la grille
    160.     affichecurseur(ligne,colonne)   # le curseur
    161.     # attente...
    162.     unetouche=ecran.getch()         # attente d'une frappe clavier
    163.  
    164. ############################################
    165. #  F I N
    166. ############################################
    167. curses.endwin()  # revenir à la console
  2. Modifier l'analyse de la frappe clavier pour tenir compte de découvrir et marquer-démarquer.
    demineur005.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##   C I N Q U 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.  
    38. ############################################
    39. # Pour les couleurs
    40. ############################################
    41. curses.start_color()
    42.  
    43. #  Jeu de couleurs pour le curseur
    44. COULEURCURSEUR=1
    45. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    46. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    47.  
    48. #  Jeu de couleurs pour la grille
    49. COULEURGRILLE=2
    50. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    51. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    52.  
    53. #  Jeu de couleurs pour une case couverte
    54. COULEURCOUVERTE=3
    55. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    56. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    57.  
    58. #  Jeu de couleurs pour une case découverte
    59. COULEURDECOUVERTE=4
    60. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    61. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    62.  
    63. #  Jeu de couleurs pour une case marquée
    64. COULEURMARQUE=5
    65. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    66. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    67.  
    68.  
    69. ############################################
    70. # Définition des caractères des cadres
    71. ############################################
    72. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    73. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    74. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    75. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    76. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    77. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    78. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    79. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    80. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    81. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    82. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    83.  
    84. ############################################
    85. #  F O N C T I O N S
    86. ############################################
    87. # == affichage de la grille ==
    88. def affichagegrille() :
    89.     # création des lignes verticales
    90.     for c in range(0,maxc+1) :                   # pour chaque ligne
    91.         for l in range(1,ecartv*maxl) :          # pour chaque case
    92.             # afficher un trait vertical
    93.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    94.     # création des lignes horizontales
    95.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    96.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    97.             if l==0 and c==0 :
    98.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    99.             elif l==0 and c == ecarth*maxc :
    100.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    101.             elif l==0 and c % ecarth == 0 :
    102.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    103.             elif l==maxl and c==0 :
    104.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    105.             elif l==maxl and c == ecarth*maxc :
    106.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    107.             elif l==maxl and c % ecarth == 0 :
    108.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    109.             elif c==0 :
    110.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    111.             elif c==ecarth*maxc :
    112.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    113.             elif c % ecarth == 0 :
    114.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    115.             else :
    116.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    117.     # affichage du contenu
    118.     for l in range(0,maxl) :                # pour chaque ligne
    119.         for c in range(0,maxc) :            # pour chaque colonne
    120.             l0=l*ecartv+1
    121.             c0=c*ecarth+1
    122.             if terrain[l][c]==MARQUEE :
    123.                 couleur=TRAITMARQUE         # couleur pour une marque
    124.                 remplir="X"                 # dessin pour une marque
    125.             elif terrain[l][c]==COUVERTE :
    126.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    127.                 remplir=" "                 # dessin pour case non découverte
    128.             else :
    129.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    130.                 remplir=" "                 # dessin pour case découverte
    131.             for ll in range(0,ecartv-1) :   # dessin de la case
    132.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    133.  
    134. # == créer le terrain de jeu ==
    135. def creerleterrain() :
    136.     global terrain
    137.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    138.         terrain.append([])                      # ajouter une ligne au tableau
    139.         for c in range (0,maxc) :               # boucle sur chaque colonne
    140.             terrain[l].append(COUVERTE)         # créer la case
    141.  
    142. # == créer les mines ==
    143. def poserlesmines() :
    144.     global mines
    145.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    146.         mines.append([])                        # ajouter une ligne au tableau
    147.         for c in range (0,maxc) :               # boucle sur chaque colonne
    148.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    149.                 mines[l].append(True)           # cocher la case
    150.             else :                              # sinon
    151.                 mines[l].append(False)          # ne pas cocher
    152.  
    153. # ==  découvrir une case ==
    154. def decouvrir(l,c) :
    155.     global terrain
    156.     terrain[l][c]=DECOUVERTE
    157.  
    158. # ==  découvrir une case ==
    159. def changermarque(l,c) :
    160.     global terrain
    161.     if terrain[l][c]==COUVERTE :
    162.         terrain[l][c]=MARQUEE
    163.     elif  terrain[l][c]==MARQUEE :
    164.         terrain[l][c]=COUVERTE
    165.  
    166. # ==  afficher le curseur ==
    167. def affichecurseur(l,c) :
    168.     c0=c*ecarth     # colonne gauche
    169.     l0=l*ecartv     # ligne haut
    170.     c1=c0+ecarth    # colonne droite
    171.     l1=l0+ecartv    # ligne bas
    172.     # les coins
    173.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    174.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    175.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    176.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    177.     # les 2 bords horizontaux
    178.     for cc in range(c0+1,c1) :
    179.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    180.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    181.     # les 2 bords verticaux
    182.     for ll in range(l0+1,l1) :
    183.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    184.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    185.    
    186. ############################################
    187. #  C O R P S     D U    P R O G R A M M E
    188. ############################################
    189. poserlesmines()              # créer les marques
    190. creerleterrain()             # créer les marques
    191. ligne=1                      # position verticale initiale du curseur
    192. colonne=1                    # position horizontale initiale du curseur
    193. unetouche=0                  # pour pouvoir entrer dans la boucle
    194. while unetouche!=quitter :   # tant qu'on n'a pas appuyé sur la touche Q
    195.     # analyse de la frappe clavier
    196.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    197.         colonne += 1
    198.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    199.         colonne -= 1
    200.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    201.         ligne -= 1
    202.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    203.         ligne += 1
    204.     elif unetouche==marcher :                               # découvrir
    205.         decouvrir(ligne,colonne)
    206.     elif unetouche==marquer :                               # marquer/démarquer
    207.         changermarque(ligne,colonne)
    208.     # (ré-)affichage du terrain
    209.     ecran.clear()                   # effacer l'écran
    210.     affichagegrille()               # la grille
    211.     affichecurseur(ligne,colonne)   # le curseur
    212.     # attente...
    213.     unetouche=ecran.getch()         # attente d'une frappe clavier
    214.  
    215. ############################################
    216. #  F I N
    217. ############################################
    218. curses.endwin()  # revenir à la console
  3. Ajouter la fonction suivante dans le programme :
               def voisins( lig , col ) :
                   return lig+col
    Cette fonction est (pour l'instant) totalement inintéressante. On en fera quelque chose de bien un peu plus loin.
  4. Modifier ensuite la fonction affichegrille() pour que dans chaque case découverte de coordonnées (L,C) elle affiche le résultat renvoyé par l'appel de voisins(L,C).
    demineur006.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##     S 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.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.  
    38. ############################################
    39. # Pour les couleurs
    40. ############################################
    41. curses.start_color()
    42.  
    43. #  Jeu de couleurs pour le curseur
    44. COULEURCURSEUR=1
    45. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    46. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    47.  
    48. #  Jeu de couleurs pour la grille
    49. COULEURGRILLE=2
    50. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    51. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    52.  
    53. #  Jeu de couleurs pour une case couverte
    54. COULEURCOUVERTE=3
    55. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    56. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    57.  
    58. #  Jeu de couleurs pour une case découverte
    59. COULEURDECOUVERTE=4
    60. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    61. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    62.  
    63. #  Jeu de couleurs pour une case marquée
    64. COULEURMARQUE=5
    65. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    66. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    67.  
    68. ############################################
    69. # Définition des caractères des cadres
    70. ############################################
    71. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    72. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    73. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    74. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    75. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    76. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    77. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    78. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    79. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    80. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    81. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    82.  
    83. ############################################
    84. #  F O N C T I O N S
    85. ############################################
    86. # == affichage de la grille ==
    87. def affichagegrille() :
    88.     # création des lignes verticales
    89.     for c in range(0,maxc+1) :                   # pour chaque ligne
    90.         for l in range(1,ecartv*maxl) :          # pour chaque case
    91.             # afficher un trait vertical
    92.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    93.     # création des lignes horizontales
    94.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    95.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    96.             if l==0 and c==0 :
    97.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    98.             elif l==0 and c == ecarth*maxc :
    99.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    100.             elif l==0 and c % ecarth == 0 :
    101.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    102.             elif l==maxl and c==0 :
    103.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    104.             elif l==maxl and c == ecarth*maxc :
    105.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    106.             elif l==maxl and c % ecarth == 0 :
    107.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    108.             elif c==0 :
    109.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    110.             elif c==ecarth*maxc :
    111.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    112.             elif c % ecarth == 0 :
    113.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    114.             else :
    115.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    116.     # affichage du contenu
    117.     for l in range(0,maxl) :                # pour chaque ligne
    118.         for c in range(0,maxc) :            # pour chaque colonne
    119.             l0=l*ecartv+1
    120.             c0=c*ecarth+1
    121.             if terrain[l][c]==MARQUEE :
    122.                 couleur=TRAITMARQUE         # couleur pour une marque
    123.                 remplir="X"                 # dessin pour une marque
    124.             elif terrain[l][c]==COUVERTE :
    125.                 couleur=TRAITCOUVERTE       # couleur pour case non découverte
    126.                 remplir=" "                 # dessin pour case non découverte
    127.             else :
    128.                 couleur=TRAITDECOUVERTE     # couleur pour case découverte
    129.                 remplir=" "                 # dessin pour case découverte
    130.             for ll in range(0,ecartv-1) :   # dessin de la case
    131.                 ecran.addstr(l0+ll,c0,remplir*(ecarth-1),couleur)
    132.             if terrain[l][c]==DECOUVERTE :
    133.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    134.  
    135. # == compter les voisins d'une case ==
    136. def voisins( lig , col ) :
    137.     return lig+col
    138.  
    139. # == créer le terrain de jeu ==
    140. def creerleterrain() :
    141.     global terrain
    142.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    143.         terrain.append([])                      # ajouter une ligne au tableau
    144.         for c in range (0,maxc) :               # boucle sur chaque colonne
    145.             terrain[l].append(COUVERTE)         # créer la case
    146.  
    147. # == créer les mines ==
    148. def poserlesmines() :
    149.     global mines
    150.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    151.         mines.append([])                        # ajouter une ligne au tableau
    152.         for c in range (0,maxc) :               # boucle sur chaque colonne
    153.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    154.                 mines[l].append(True)           # cocher la case
    155.             else :                              # sinon
    156.                 mines[l].append(False)          # ne pas cocher
    157.  
    158. # ==  découvrir une case ==
    159. def decouvrir(l,c) :
    160.     global terrain
    161.     terrain[l][c]=DECOUVERTE
    162.  
    163. # ==  découvrir une case ==
    164. def changermarque(l,c) :
    165.     global terrain
    166.     if terrain[l][c]==COUVERTE :
    167.         terrain[l][c]=MARQUEE
    168.     elif  terrain[l][c]==MARQUEE :
    169.         terrain[l][c]=COUVERTE
    170.  
    171. # ==  afficher le curseur ==
    172. def affichecurseur(l,c) :
    173.     c0=c*ecarth     # colonne gauche
    174.     l0=l*ecartv     # ligne haut
    175.     c1=c0+ecarth    # colonne droite
    176.     l1=l0+ecartv    # ligne bas
    177.     # les coins
    178.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    179.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    180.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    181.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    182.     # les 2 bords horizontaux
    183.     for cc in range(c0+1,c1) :
    184.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    185.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    186.     # les 2 bords verticaux
    187.     for ll in range(l0+1,l1) :
    188.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    189.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    190.    
    191. ############################################
    192. #  C O R P S     D U    P R O G R A M M E
    193. ############################################
    194. poserlesmines()              # créer les marques
    195. creerleterrain()             # créer les marques
    196. ligne=1                      # position verticale initiale du curseur
    197. colonne=1                    # position horizontale initiale du curseur
    198. unetouche=0                  # pour pouvoir entrer dans la boucle
    199. while unetouche!=quitter :   # tant qu'on n'a pas appuyé sur la touche Q
    200.     # analyse de la frappe clavier
    201.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    202.         colonne += 1
    203.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    204.         colonne -= 1
    205.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    206.         ligne -= 1
    207.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    208.         ligne += 1
    209.     elif unetouche==marcher :                               # découvrir
    210.         decouvrir(ligne,colonne)
    211.     elif unetouche==marquer :                               # marquer/démarquer
    212.         changermarque(ligne,colonne)
    213.     # (ré-)affichage du terrain
    214.     ecran.clear()                   # effacer l'écran
    215.     affichagegrille()               # la grille
    216.     affichecurseur(ligne,colonne)   # le curseur
    217.     # attente...
    218.     unetouche=ecran.getch()         # attente d'une frappe clavier
    219.  
    220. ############################################
    221. #  F I N
    222. ############################################
    223. curses.endwin()  # revenir à la console
Dernière modification : 25/8/2016
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) : [Voir le TD n°8]
Dernière modification : 25/8/2016