Déroulement réel des cours

La « pensée » du Dimec'hrer, d'an 21 a viz Eost 2019 , 22h01m11s :
On construit des maisons de fous pour faire croire à ceux qui n'y sont pas enfermés qu'ils ont encore la raison.
  -- Montaigne
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) :
  • Modifiez la fonction voisins(lig,col) pour qu'elle renvoie le nombre de mines dans les cases mitoyennes de la case de coordonnées (lig,col). Vous commencez à voir à quoi ça sert ?
    Point important : le plus simple est sans doute de faire une double boucle qui parcourt le carré 3×3 dont la case est le centre. Mais ça ne marche pas quand la case est sur un bord.
    Pour vérifier que ça marche, pensez à ajouter dans l'affichage du terrain la représentation des mines éventuelles dans les cases découvertes.
  • Amélioration : si la valeur renvoyée par la fonction est zéro, il faudrait que rien ne s'affiche.
    demineur007.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##   S E P T I È M E    V E R S I O N     ##
    6. ##                                        ##
    7. ##          D U     P R O J E T           ##
    8. ##                                        ##
    9. ##            D É M I N E U R             ##
    10. ##                                        ##
    11. ############################################
    12. ############################################
    13. import random,curses
    14. ############################################
    15. #  I N I T I A L I S A T I O N S
    16. ############################################
    17. ecran=curses.initscr()  # création de l'écran "graphique"
    18. ecran.keypad(True)      # codage des touches de fonctions en 1 octet
    19. curses.curs_set(False)  # pas d'affichage du curseur
    20.  
    21. ############################################
    22. #  P A R A M È T R E S
    23. ############################################
    24. maxl=8              # nombre de lignes dans la grille
    25. maxc=14             # nombre de colonnes dans la grille
    26. ecarth=4            # écart entre deux lignes horizontales
    27. ecartv=3            # écart entre deux lignes verticales
    28. marcher=ord(" ")    # touche pour découvrir une cellule (marcher dessus)
    29. marquer=ord("*")    # touche pour marquer/démarquer une cellule
    30. quitter=ord("q")    # touche pour quitter
    31. terrain=[]          # création du terrain de jeu vide
    32. mines=[]            # création du tableau des mines vide
    33. probamarques=0.2    # probabilité d'apparition des marques
    34. COUVERTE=0          # état original des cases
    35. DECOUVERTE=1        # case découverte
    36. MARQUEE=2           # case marquée
    37. DESSINMINE="XXX"    # représentation d'une mine à l'écran
    38.  
    39. ############################################
    40. # Pour les couleurs
    41. ############################################
    42. curses.start_color()
    43.  
    44. #  Jeu de couleurs pour le curseur
    45. COULEURCURSEUR=1
    46. curses.init_pair(COULEURCURSEUR,curses.COLOR_RED,curses.COLOR_BLACK)
    47. TRAITCURSEUR=curses.color_pair(COULEURCURSEUR)+curses.A_BOLD
    48.  
    49. #  Jeu de couleurs pour la grille
    50. COULEURGRILLE=2
    51. curses.init_pair(COULEURGRILLE,curses.COLOR_GREEN,curses.COLOR_BLACK)
    52. TRAITGRILLE=curses.color_pair(COULEURGRILLE)+curses.A_BOLD
    53.  
    54. #  Jeu de couleurs pour une case couverte
    55. COULEURCOUVERTE=3
    56. curses.init_pair(COULEURCOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLUE)
    57. TRAITCOUVERTE=curses.color_pair(COULEURCOUVERTE)
    58.  
    59. #  Jeu de couleurs pour une case découverte
    60. COULEURDECOUVERTE=4
    61. curses.init_pair(COULEURDECOUVERTE,curses.COLOR_WHITE,curses.COLOR_BLACK)
    62. TRAITDECOUVERTE=curses.color_pair(COULEURDECOUVERTE)
    63.  
    64. #  Jeu de couleurs pour une case marquée
    65. COULEURMARQUE=5
    66. curses.init_pair(COULEURMARQUE,curses.COLOR_BLACK,curses.COLOR_YELLOW)
    67. TRAITMARQUE=curses.color_pair(COULEURMARQUE)+curses.A_BOLD
    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.             if terrain[l][c]==DECOUVERTE :
    134.                 ecran.addstr(l0,c0,str(voisins(l,c)),TRAITDECOUVERTE)
    135.                 if mines[l][c] :
    136.                     ecran.addstr(l0+1,c0,DESSINMINE,TRAITDECOUVERTE)
    137.  
    138. # == compter les voisins d'une case ==
    139. def voisins( lig , col ) :
    140.     # détermination des limites d'exploration
    141.     if lig==0 :      # si trop haut
    142.         l0=lig       # commencer sur cette ligne
    143.     else :           # sinon
    144.         l0=lig-1     # commencer à la ligne du dessus
    145.     if lig==maxl-1 : # si trop haut
    146.         l1=lig       # finir sur cette ligne
    147.     else :           # sinon
    148.         l1=lig+1     # finir sur la ligne du dessous
    149.     if col==0 :      # si trop à gauche
    150.         c0=col       # commencer sur cette colonne
    151.     else :           # sinon
    152.         c0=col-1     # commencer sur la colonne précédente
    153.     if col==maxc-1 : # si trop à droite
    154.         c1=col       # commencer sur cette colonne
    155.     else :           # sinon
    156.         c1=col+1     # commencer sur la colonne suivante
    157.     # exploration des cases voisines
    158.     n=0                             # initialisation du compteur
    159.     for l in range (l0,l1+1) :      # pour toutes les lignes
    160.         for c in range (c0,c1+1) :  # pour toutes les colonnes
    161.             if l!=lig or c!=col :   # si on n'est pas sur la case en cours
    162.                 if mines[l][c] :    # et que la case est minée
    163.                     n += 1          # incrémenter le compteur
    164.     # renvoyer les résultats
    165.     if n>0 :           # si il y a des voisins minés
    166.         return str(n)  # renvoyer leur nombre (converti en chaîne de caractères)
    167.     return ""          # [sinon] renvoyer une chaîne vide (pas d'affichage)
    168.  
    169.  
    170. # == créer le terrain de jeu ==
    171. def creerleterrain() :
    172.     global terrain
    173.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    174.         terrain.append([])                      # ajouter une ligne au tableau
    175.         for c in range (0,maxc) :               # boucle sur chaque colonne
    176.             terrain[l].append(COUVERTE)         # créer la case
    177.  
    178. # == créer les mines ==
    179. def poserlesmines() :
    180.     global mines
    181.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    182.         mines.append([])                        # ajouter une ligne au tableau
    183.         for c in range (0,maxc) :               # boucle sur chaque colonne
    184.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    185.                 mines[l].append(True)           # cocher la case
    186.             else :                              # sinon
    187.                 mines[l].append(False)          # ne pas cocher
    188.  
    189. # ==  découvrir une case ==
    190. def decouvrir(l,c) :
    191.     global terrain
    192.     terrain[l][c]=DECOUVERTE
    193.  
    194. # ==  découvrir une case ==
    195. def changermarque(l,c) :
    196.     global terrain
    197.     if terrain[l][c]==COUVERTE :
    198.         terrain[l][c]=MARQUEE
    199.     elif  terrain[l][c]==MARQUEE :
    200.         terrain[l][c]=COUVERTE
    201.  
    202. # ==  afficher le curseur ==
    203. def affichecurseur(l,c) :
    204.     c0=c*ecarth     # colonne gauche
    205.     l0=l*ecartv     # ligne haut
    206.     c1=c0+ecarth    # colonne droite
    207.     l1=l0+ecartv    # ligne bas
    208.     # les coins
    209.     ecran.addch(l0,c0,HG,TRAITCURSEUR)
    210.     ecran.addch(l0,c1,HD,TRAITCURSEUR)
    211.     ecran.addch(l1,c0,BG,TRAITCURSEUR)
    212.     ecran.addch(l1,c1,BD,TRAITCURSEUR)
    213.     # les 2 bords horizontaux
    214.     for cc in range(c0+1,c1) :
    215.         ecran.addch(l0,cc,horizontal,TRAITCURSEUR) # haut
    216.         ecran.addch(l1,cc,horizontal,TRAITCURSEUR) # bas
    217.     # les 2 bords verticaux
    218.     for ll in range(l0+1,l1) :
    219.         ecran.addch(ll,c0,vertical,TRAITCURSEUR) # gauche
    220.         ecran.addch(ll,c1,vertical,TRAITCURSEUR) # droite
    221.    
    222. ############################################
    223. #  C O R P S     D U    P R O G R A M M E
    224. ############################################
    225. poserlesmines()              # créer les marques
    226. creerleterrain()             # créer les marques
    227. ligne=1                      # position verticale initiale du curseur
    228. colonne=1                    # position horizontale initiale du curseur
    229. unetouche=0                  # pour pouvoir entrer dans la boucle
    230. while unetouche!=quitter :   # tant qu'on n'a pas appuyé sur la touche Q
    231.     # analyse de la frappe clavier
    232.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    233.         colonne += 1
    234.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    235.         colonne -= 1
    236.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    237.         ligne -= 1
    238.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    239.         ligne += 1
    240.     elif unetouche==marcher :                               # découvrir
    241.         decouvrir(ligne,colonne)
    242.     elif unetouche==marquer :                               # marquer/démarquer
    243.         changermarque(ligne,colonne)
    244.     # (ré-)affichage du terrain
    245.     ecran.clear()                   # effacer l'écran
    246.     affichagegrille()               # la grille
    247.     affichecurseur(ligne,colonne)   # le curseur
    248.     # attente...
    249.     unetouche=ecran.getch()         # attente d'une frappe clavier
    250.  
    251. ############################################
    252. #  F I N
    253. ############################################
    254. curses.endwin()  # revenir à la console
Dernière modification : 25/8/2016
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