# Partie 1 (2H environ) : Manipulation de caractères

## Introduction

                                      ```````
                             ```'''`````  ``````'''`,,`
                        ```'`                         ``'``
                     ,`'                                   ''``
                  ,'`                                         `^,
               `,'                                               `'`
            ,,!~..`````````````````````,`'`,,``````````````````'''.'!,,
            |'~ws\~`                `/kx^^''~!,                `,~x?J~~`
          `-'  `~*.-,-'``,`         *XO**^*\k);`         `,,--^./r!~' ^-`
         _' '      `^',`  `^,```    *5Q[jx/]%*/     `,,-'` ``,--`     -`'`
        _'  ',,,`      `''',._``,-'^-%%{*/~7Y)--_^^'```,,`'''      ```_` ^`
       `^   xcanr_~~,``'''^-''^-~~'``^^'^~,'^~``!_.~'~-,-''''''--:!x)=v`  ^`
       ^    ''`'''^^''``-,---'',,.~~,    `    `.x,,,,,^',``',,'--+^~~'^`   ^
      ~`    '                      =0r^,--~'+-!x`                     -`   `.
      '     '                       '    `    '^                      -`    '
     `^     '                       -`       `'                       -`    ^`
     '`     '                       '' ` _ ```'                       _`    `,
     '`     '                       x'   ^   `~                       ^`    `,
     `,     '                      `'       ` !`                      -`    `'
      '     '                     `~`  ``,'_  ''                      -`    _`
      '     '                    ````` `''~`  ,`,                     ^`    '
      `.    '                   `` '  `'`^^,  '  ,                    -`   ``
       ^`   '                   '  `,`` `' '` '  _`                   -`  `'
        ^   '                  ,' `,^   ~'  `''  `'                   -`  ^
         ^  '                `-```-`'   .'`  ,-,` '`                  -``-
          -`'              `-` `-`  .` `-^' `' ',`'!`                 -'-
           ''             .'  `'    _``.`'`'.`  ^`  ^,                ~^
           `^`           `^  `'    ,` `',  `^    ' ` `.             `-^`
           `'  '`        .  ,`     '   '.   ,     ',  ,`          `'` -`
           `'    ``     `'`'       '`  .'`  ,      `,` -`       `'`   _`
           `'       ``^--`^         '  ^ ~  ,        '. '-,_.,'`      -`
           `'         `^-~'         `'`-`^  !         ^_`.,^`         ^`
           `'             ``         ,-`^`'`'''`    ```'`             ,`
           `-'''''''''''''''''''---+*Y!+~=^''''--~-'''````````````````-`

La transformation d'une image en Ascii-Art (voir image ci-contre) nécessite de manipuler des caractères (des lettres), ceux qui servent à reconstituer l'image. Dans ce premier TP, nous nous concentrons donc sur la forme graphique des caractères, fournie sous forme de matrice.

## Objectifs du TP

- Afficher les trames des caractères (parcours de matrice)

## Acteur utilisé

L'acteur Caracteres

## Consignes

- Créez un dossier pour tous vos prochains TPs d'algo, nommez-le algo2 (sans espace !). Copiez-y le fichier mission1.adb que vous trouvez sur commetud.
- Écrire un programme `Mission1` qui demande poliment à l'utilisateur de taper un entier (n) et qui affiche ensuite la valeur de n. Testez.
- Complétez votre programme : affichez ensuite le caractère contenu dans la n-ème case de la table, avec `GAda.Text_IO.Put(Aff : character)`. Conseils :
  - Pour tester : le caractère numéro 32 est un 'C'.
  - Il vous faut bien comprendre l'acteur Caracteres. Pour cela, réfléchissez à deux, et lisez ces commentaires :
  - L'information que l'on cherche se trouve dans la variable Table. C'est un tableau (array). Voyez votre poly pour comprendre ce qu'est un tableau.
  - Chaque case de ce tableau contient un type article T_Paire (chaque case est différente). On vous demande d'afficher le caractère contenu dans cet article.
  - En résumé, il faut donc trouver comment accéder à la N-ème case de la Table, et obtenir le caractère contenu dans le type article présent dans cette case.
- Ajoutez un sous-programme : la procédure `Afficher_Trame`avec un argument (la trame à afficher). Pour afficher la trame, on parcourt la matrice ligne par ligne et colonne par colonne. Si la case contient un pixel allumé, on affiche un # (avec GAda.Text_IO.PUT), si le pixel est éteint, un espace.
  Pour détecter si le pixel est éteint ou allumé, utiliser un bloc CASE.
- Pensez à ajouter une procédure de test : `Tester_Afficher_Trame` qui affiche la trame de 3 ou 4 caractères de votre choix.
- Écrivez une procédure `Afficher_Mot` qui reçoit en argument une chaîne (String) et qui affiche verticalement les trames des caractères de cette chaîne. Si vous avez besoin de créer une fonction auxiliaire, c'est normal.
  Le type String est un tableau de Character. Le numéro de la première case n'est pas 1, il s'obtient avec la notation `'First`
  Testez en affichant votre nom.
- (Si vous êtes en avance) afficher maintenant votre nom horizontalement. N'oubliez pas d'écrire d'abord l'algorigramme sur papier.