Déroulement réel des cours

La « pensée » du vendredi 15 février 2019, 22h40m13s :
"You know, it's at times like this when I'm trapped in a Vogon airlock with a man from Betelgeuse and about to die of asphyxiation in deep space that I really wish I'd listened to what my mother told me when I was young!"
"Why, what did she tell you?"
"I don't know, I didn't listen!"
  -- Douglas Adams, "Hitchhiker's Guide to the Galaxy"
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) :
Retour sur le TD n°3 :
  • Mettre en valeur du texte avec curses
    On peut ajouter des attributs au texte qui permettent de le mettre en valeur. Ce sont les attributs : A_BLINK (texte clignotant), A_BOLD (extra brillant ou gras), A_DIM (brillant moyen), A_REVERSE (video inverse), A_STANDOUT (le meilleur mode de mise en valeur disponible), A_UNDERLINE (souligné).
    Il faut avoir à l'esprit que certaines de ces valeurs peuvent produire les mêmes effets que d'autres, ou même ne produire aucun effet du tout : cela dépend des capacités du terminal.
    On peut utiliser ces attributs combinés aux couleurs en les additionnant comme pour le dernier affichage de l'exemple précédent.
  • La fonction affichecurseur() dessine un vrai curseur comme dans l'exemple donné au TD 1.
    demineur002.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##    D E U 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=10                 # nombre de lignes dans la grille
    25. maxc=10                 # nombre de colonnes dans la grille
    26. ecarth=4                # écart entre deux lignes horizontales
    27. ecartv=3                # écart entre deux lignes verticales
    28. changemarque=ord(" ")   # touche pour marquer/démarquer une cellule
    29. terrain=[]              # création du tableau vide
    30. marque="XXX"            # dessin de la marque
    31. curseurmarque="***"     # le curseur + la marque
    32. probamarques=0.2        # probabilité d'apparition des marques
    33.  
    34. ############################################
    35. # Pour les couleurs
    36. ############################################
    37. curses.start_color()
    38.  
    39. #  Jeu de couleurs pour le curseur
    40. COULEURCURSEUR=1
    41. curses.init_pair(COULEURCURSEUR,curses.COLOR_CYAN,curses.COLOR_BLACK)
    42.  
    43. ############################################
    44. # Définition des caractères des cadres
    45. ############################################
    46. HG = curses.ACS_ULCORNER       # ou ACS_BSSB
    47. HD = curses.ACS_URCORNER       # ou ACS_BBSS
    48. BG = curses.ACS_LLCORNER       # ou ACS_SSBB
    49. BD = curses.ACS_LRCORNER       # ou ACS_SBBS
    50. horizontal = curses.ACS_HLINE  # ou ACS_BSBS
    51. vertical = curses.ACS_VLINE    # ou ACS_SBSB
    52. intersection = curses.ACS_PLUS # ou ACS_SSSS
    53. jointureH = curses.ACS_TTEE    # ou ACS_BSSS
    54. jointureB = curses.ACS_BTEE    # ou ACS_SSBS
    55. jointureG = curses.ACS_LTEE    # ou ACS_SSSB
    56. jointureD = curses.ACS_RTEE    # ou ACS_SBSS
    57.  
    58. ############################################
    59. #  F O N C T I O N S
    60. ############################################
    61. # == affichage de la grille ==
    62. def affichagegrille() :
    63.     # création des lignes horizontales
    64.     for l in range(0,maxl+1) :                 # pour chaque ligne
    65.         for c in range(0,ecarth*maxc+1):       # pour chaque case
    66.             ecran.addch(l*ecartv,c,horizontal) # afficher une ligne horizontale
    67.     # création des lignes verticales
    68.     for c in range(0,maxc+1) :                       # pour chaque ligne
    69.         for l in range(0,ecartv*maxl+1) :            # pour chaque case
    70.             if l % ecartv == 0 :                     # tous les "ecarth" lignes
    71.                 ecran.addch(l,c*ecarth,intersection) # afficher une intersection
    72.             else :                                   # sinon...
    73.                 ecran.addch(l,c*ecarth,vertical)     # afficher un trait vertical
    74.  
    75. # == créer les marques ==
    76. def poserlesmarques() :
    77.     global terrain
    78.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    79.         terrain.append([])                      # ajouter une ligne au tableau
    80.         for c in range (0,maxc) :               # boucle sur chaque colonne
    81.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    82.                 terrain[l].append(True)         # cocher la case
    83.             else :                              # sinon
    84.                 terrain[l].append(False)        # ne pas cocher
    85.  
    86. # ==  afficher les marques ==
    87. def affichemarques() :
    88.     for l in range(0,maxl) :                                # boucle sur chaque ligne
    89.         for c in range(0,maxc) :                            # boucle sur chaque colonne
    90.             if terrain[l][c] :                              # si la case est "cochée"
    91.                 ecran.addstr(l*ecartv+1,c*ecarth+1,marque)  # afficher (sinon rien)
    92.  
    93. # ==  afficher le curseur ==
    94. def affichecurseur(l,c) :
    95.     c0=c*ecarth     # colonne gauche
    96.     l0=l*ecartv     # ligne haut
    97.     c1=c0+ecarth    # colonne droite
    98.     l1=l0+ecartv    # ligne bas
    99.     # les coins
    100.     ecran.addch(l0,c0,HG,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD)
    101.     ecran.addch(l0,c1,HD,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD)
    102.     ecran.addch(l1,c0,BG,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD)
    103.     ecran.addch(l1,c1,BD,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD)
    104.     # les 2 bords horizontaux
    105.     for cc in range(c0+1,c1) :
    106.         ecran.addch(l0,cc,horizontal,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD) # haut
    107.         ecran.addch(l1,cc,horizontal,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD) # bas
    108.     # les 2 bords verticaux
    109.     for ll in range(l0+1,l1) :
    110.         ecran.addch(ll,c0,vertical,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD) # gauche
    111.         ecran.addch(ll,c1,vertical,curses.color_pair(COULEURCURSEUR)+curses.A_BOLD) # droite
    112.    
    113. ############################################
    114. #  C O R P S     D U    P R O G R A M M E
    115. ############################################
    116. poserlesmarques()            # créer les marques
    117. ligne=1                      # position verticale initiale du curseur
    118. colonne=1                    # position horizontale initiale du curseur
    119. unetouche=0                  # pour pouvoir entrer dans la boucle
    120. while unetouche!=ord("q") :  # tant qu'on n'a pas appuyé sur la touche Q
    121.     # analyse de la frappe clavier
    122.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    123.         colonne += 1
    124.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    125.         colonne -= 1
    126.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    127.         ligne -= 1
    128.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    129.         ligne += 1
    130.     elif unetouche==changemarque :                          # marquer/démarquer
    131.         terrain[ligne][colonne] = not terrain[ligne][colonne]
    132.     # (ré-)affichage du terrain
    133.     ecran.clear()                   # effacer l'écran
    134.     affichagegrille()               # la grille
    135.     affichemarques()                # les marques
    136.     affichecurseur(ligne,colonne)   # le curseur
    137.     # attente...
    138.     unetouche=ecran.getch()         # attente d'une frappe clavier
    139.  
    140. ############################################
    141. #  F I N
    142. ############################################
    143. curses.endwin()  # revenir à la console
Suite du projet :
  • Modifier le programme pour qu'il dessine une belle grille.
    demineur003.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##   T R O I S 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=10                 # nombre de lignes dans la grille
    25. maxc=10                 # nombre de colonnes dans la grille
    26. ecarth=4                # écart entre deux lignes horizontales
    27. ecartv=3                # écart entre deux lignes verticales
    28. changemarque=ord(" ")   # touche pour marquer/démarquer une cellule
    29. terrain=[]              # création du tableau vide
    30. marque="XXX"            # dessin de la marque
    31. curseurmarque="***"     # le curseur + la marque
    32. probamarques=0.2        # probabilité d'apparition des marques
    33.  
    34. ############################################
    35. # Pour les couleurs
    36. ############################################
    37. curses.start_color()
    38.  
    39. #  Jeu de couleurs pour le curseur
    40. COULEURCURSEUR=1
    41. curses.init_pair(COULEURCURSEUR,curses.COLOR_CYAN,curses.COLOR_BLACK)
    42. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    43.  
    44. #  Jeu de couleurs pour la grille
    45. COULEURGRILLE=2
    46. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    47. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    48.  
    49. ############################################
    50. # Définition des caractères des cadres
    51. ############################################
    52. HG = curses.ACS_ULCORNER       # ou ACS_BSSB : ┌
    53. HD = curses.ACS_URCORNER       # ou ACS_BBSS :  ┐
    54. BG = curses.ACS_LLCORNER       # ou ACS_SSBB : └
    55. BD = curses.ACS_LRCORNER       # ou ACS_SBBS :  ┘
    56. horizontal = curses.ACS_HLINE  # ou ACS_BSBS : ─
    57. vertical = curses.ACS_VLINE    # ou ACS_SBSB :  │
    58. intersection = curses.ACS_PLUS # ou ACS_SSSS : ┼
    59. jointureH = curses.ACS_TTEE    # ou ACS_BSSS :  ┬
    60. jointureB = curses.ACS_BTEE    # ou ACS_SSBS : ┴
    61. jointureG = curses.ACS_LTEE    # ou ACS_SSSB :  ├
    62. jointureD = curses.ACS_RTEE    # ou ACS_SBSS : ┤
    63.  
    64. ############################################
    65. #  F O N C T I O N S
    66. ############################################
    67. # == affichage de la grille ==
    68. def affichagegrille() :
    69.     # création des lignes verticales
    70.     for c in range(0,maxc+1) :                   # pour chaque ligne
    71.         for l in range(1,ecartv*maxl) :          # pour chaque case
    72.             # afficher un trait vertical
    73.             ecran.addch(l,c*ecarth,vertical,TRAITGRILLE)  
    74.     # création des lignes horizontales
    75.     for l in range(0,maxl+1) :                                   # pour chaque ligne
    76.         for c in range(0,ecarth*maxc+1) :                        # pour chaque colonne
    77.             if l==0 and c==0 :
    78.                 ecran.addch(l*ecartv,c,HG,TRAITGRILLE)           # coin Haut Gauche
    79.             elif l==0 and c == ecarth*maxc :
    80.                 ecran.addch(l*ecartv,c,HD,TRAITGRILLE)           # coin Haut Droit
    81.             elif l==0 and c % ecarth == 0 :
    82.                 ecran.addch(l*ecartv,c,jointureH,TRAITGRILLE)    # jointure sur le bord haut
    83.             elif l==maxl and c==0 :
    84.                 ecran.addch(l*ecartv,c,BG,TRAITGRILLE)           # coin Bas Gauche
    85.             elif l==maxl and c == ecarth*maxc :
    86.                 ecran.addch(l*ecartv,c,BD,TRAITGRILLE)           # coin Bas Droit
    87.             elif l==maxl and c % ecarth == 0 :
    88.                 ecran.addch(l*ecartv,c,jointureB,TRAITGRILLE)    # jointure sur le bord bas
    89.             elif c==0 :
    90.                 ecran.addch(l*ecartv,c,jointureG,TRAITGRILLE)    # jointure sur le bord gauche
    91.             elif c==ecarth*maxc :
    92.                 ecran.addch(l*ecartv,c,jointureD,TRAITGRILLE)    # jointure sur le bord droit
    93.             elif c % ecarth == 0 :
    94.                 ecran.addch(l*ecartv,c,intersection,TRAITGRILLE) # intersection
    95.             else :
    96.                 ecran.addch(l*ecartv,c,horizontal,TRAITGRILLE)   # sinon trait horizontal
    97.  
    98. # == créer les marques ==
    99. def poserlesmarques() :
    100.     global terrain
    101.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    102.         terrain.append([])                      # ajouter une ligne au tableau
    103.         for c in range (0,maxc) :               # boucle sur chaque colonne
    104.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    105.                 terrain[l].append(True)         # cocher la case
    106.             else :                              # sinon
    107.                 terrain[l].append(False)        # ne pas cocher
    108.  
    109. # ==  afficher les marques ==
    110. def affichemarques() :
    111.     for l in range(0,maxl) :                                # boucle sur chaque ligne
    112.         for c in range(0,maxc) :                            # boucle sur chaque colonne
    113.             if terrain[l][c] :                              # si la case est "cochée"
    114.                 ecran.addstr(l*ecartv+1,c*ecarth+1,marque)  # afficher (sinon rien)
    115.  
    116. # ==  afficher le curseur ==
    117. def affichecurseur(l,c) :
    118.     c0=c*ecarth     # colonne gauche
    119.     l0=l*ecartv     # ligne haut
    120.     c1=c0+ecarth    # colonne droite
    121.     l1=l0+ecartv    # ligne bas
    122.     # les coins
    123.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    124.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    125.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    126.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    127.     # les 2 bords horizontaux
    128.     for cc in range(c0+1,c1) :
    129.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    130.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    131.     # les 2 bords verticaux
    132.     for ll in range(l0+1,l1) :
    133.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    134.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    135.    
    136. ############################################
    137. #  C O R P S     D U    P R O G R A M M E
    138. ############################################
    139. poserlesmarques()            # créer les marques
    140. ligne=1                      # position verticale initiale du curseur
    141. colonne=1                    # position horizontale initiale du curseur
    142. unetouche=0                  # pour pouvoir entrer dans la boucle
    143. while unetouche!=ord("q") :  # tant qu'on n'a pas appuyé sur la touche Q
    144.     # analyse de la frappe clavier
    145.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    146.         colonne += 1
    147.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    148.         colonne -= 1
    149.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    150.         ligne -= 1
    151.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    152.         ligne += 1
    153.     elif unetouche==changemarque :                          # marquer/démarquer
    154.         terrain[ligne][colonne] = not terrain[ligne][colonne]
    155.     # (ré-)affichage du terrain
    156.     ecran.clear()                   # effacer l'écran
    157.     affichagegrille()               # la grille
    158.     affichemarques()                # les marques
    159.     affichecurseur(ligne,colonne)   # le curseur
    160.     # attente...
    161.     unetouche=ecran.getch()         # attente d'une frappe clavier
    162.  
    163. ############################################
    164. #  F I N
    165. ############################################
    166. curses.endwin()  # revenir à la console
  • Structures de données : quelles sont les informations à garder en cours de partie ?
    • Le terrain : chaque case peut être dans l'état original (non encore découverte), découverte, ou marquée comme pouvant contenir une mine. (Dans le vrai jeu il y a même un quatrième état : en attente, symbolisé par un point d'interrogation.) On utilisera une liste (à deux dimensions) de n'importe quel type de données qui permette de coder facilement trois valeurs distinctes. Autrement dit, on prend ce qu'on veut. Mais il est impératif d'utiliser des constantes nommées.
    • Les mines : deux états pour chaque case, présente ou pas. On utilisera une liste (à deux dimensions) de n'importe quel type de données qui permette de coder facilement deux valeurs distinctes. Les booléens, par exemple. Mais on peut aussi choisir la méthode utilisée pour le terrain, des constantes nommées.
    On aura donc deux listes :
    terrain=[]
    mines=[]
    Toutes deux auront maxl lignes et maxc colonnes.
    mines sera initialisée comme l'était terrain dans les programmes précédents, mais ne sera jamais modifiée dans le cours du programme.
    terrain sera initialisée avec la même valeur pour toutes les cases, celle correspondant à non encore découverte. Chaque case pourra passer à l'état découverte ou marquée par l'appui d'une touche. C'est le traitement qui était effectué dans les programmes précédents.
Dernière modification : 25/8/2016
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) : [Voir le TD n°8]
Dernière modification : 25/8/2016