Guide Tutoriel de BBC BASIC for Windows, Ch. 13

Chapitre 13 — D'autres façons d'entrer des informations

GET et GET$

Le problème avec INPUT, c'est qu'il faut taper sur les touches que vous voulez, puis taper  Entrée . Si vous voulez que l'utilisateur entre des informations sur lesquelles le programme peut agir, comme le rayon d'un cercle, c'est bon, mais à certains moments le clavier peut servir à autre chose. GET attend qu'une touche soit pressée et renvoie le code ASCII de cette touche, sans l'afficher à l'écran. On peut se servir de cela pour affecter à une variable la touche qui vient d'être pressée, ou plus simplement, attendre qu'une touche soit pressée après l'affichage d'un écran d'informations.

      REM GET démonstration
      PRINT "Appuyez sur une touche pour continuer"
      Frappe% = GET
      PRINT "Code de la touche pressée : ";Frappe%
      END
    

GET prend en compte les touches de curseur, les touches de fonction, etc. Les codes renvoyés sont indiqués dans les fichiers d'aide sous GET/GET$, mais vous pouvez conserver le programme ci-dessus à portée de main et le lancer quand vous avez besoin de trouver le code de <Alt+F1> ou n'importe quel autre.

GET$ renvoie une chaîne d'un caractère unique qui représente la touche pressée par l'utilisateur. Comme pour son jumeau ci-dessus, une valeur est renvoyée pour chaque touche pressée, y compris les touches de fonction, etc. On récupère des caractères de valeur supérieure à 127, aussi, si vous tentez de les afficher, il se peut que vous obteniez des résultats étranges. Essayez ce petit programme et vérifiez qu'il renvoie bien des valeurs différentes pour F1, <Shift+F1>, <Ctrl+F1> et <Alt+F1>.

      REM GET$ démonstration
      Frappe$=GET$
      PRINT Frappe$,ASC(Frappe$)
      END
    

En vous servant de GET$ et de GET il devient possible de contrôler l'entrée faite par l'utilisateur, afin de vérifier que les touches sur lesquelles il a appuyé sont valides. Cela permet d'éviter un problème qui existe avec INPUT. Le BASIC attend qu'on tape  Entrée  et ensuite, il essaie de traiter le résultat, ce que, souvent, il ne peut pas faire. Voici une petite routine utile qui ne permet à l'utilisateur que d'entrer des nombres de 0 à 9, en ignorant les autres touches.

      REM Filtrage des nombres
      Ttal$=""
      PRINT "Tapez un nombre ou Entrée pour finir"
      REPEAT
        Frappe$=GET$
        IF Frappe$ >="0" AND Frappe$ <="9" THEN
          Ttal$=Ttal$+Frappe$
          PRINT TAB(0,1);Ttal$;
        ENDIF
      UNTIL ASC(Frappe$)=13
      PRINT '"Vous avez tapé : ";VAL(Ttal$)
      END
    

INKEY et INKEY$

INPUT, INPUT LINE, GET et GET$ attendent tous qu'une touche soit pressée pour que le programme puisse continuer. Nous allons maintenant mettre sous le microscope deux commandes qui permettent de spécifier une durée pendant laquelle il faut attendre avant que le BASIC abandonne l'attente et continue le programme. Les fonctions INKEY et INKEY$ peuvent toutes deux prendre un argument qui spécifie la durée en centièmes de seconde pendant laquelle il faut attendre (exactement comme notre amie, la commande WAIT). Si une touche est pressée pendant cette période de temps, la fonction renvoie sa valeur, comme avec GET et GET$. INKEY renvoie la valeur ASCII et INKEY$ renvoie une chaîne d'un seul caractère. Les codes des touches étendues (fonction, curseur, etc.) sont tout à fait les mêmes que pour GET et GET$, ce qui est vraiment une bonne chose. Si aucune touche n'est pressée pendant la durée permise, le nombre –1 est renvoyé, ou bien une chaîne vide.

      REM INKEY démonstration
      PRINT "Tapez une touche ou attendez 5 sec."
      REM 500 = 5 secondes / 0.01
      Frappe%=INKEY(500)
      IF Frappe%<>-1 THEN
        PRINT "Vous avez tapé ";Frappe%
      ELSE
        PRINT "Vous n'avez rien tapé"
      ENDIF
      END
    

Si la valeur de temps est égale à 0, les jumeaux INKEY et INKEY$ continuent immédiatement, sans attendre. C'est très utile dans les jeux où vous voulez que les extra-terrestres fassent des bonds en travers de l'écran sans attendre que le joueur ne bouge. Ce modeste exemple compte le nombre de répétitions d'une boucle jusqu'à ce qu'une touche soit pressée :

      REM INKEY$
      Cpt% = 0
      REPEAT
        WAIT 50 : REM Délai de 0.5 seconde
        Cpt% = Cpt%+1
      UNTIL INKEY$(0)<>""
      PRINT "Vous avez attendu ";Cpt%/2;" seconde(s)"
      END
    

INKEY (mais pas INKEY$) a une fonctionnalité étendue parce qu'il peut tester si des touches individuelles sont pressées. Pour faire ceci, nous lui donnons un argument négatif. Le tableau des valeurs utilisées pour représenter la touche requise n'a pas de rapport avec le code ASCII et il est donné en entier dans les fichiers d'aide, sous INKEY/INKEY$. Utilisé de cette façon, il renvoie immédiatement une valeur de TRUE (-1) ou FALSE (0), selon que la touche requise a été pressée ou non. Là encore, c'est vraiment bien pour les jeux :

      REM INKEY : détecter des touches individuelles
      PRINT "Flèches gauche et droite, Espace et x"
      REPEAT
        pause% = INKEY(1)
        IF INKEY(-26) PRINT "Déplacement à gauche"
        IF INKEY(-122) PRINT "Déplacement à droite"
        IF INKEY(-99) PRINT "FEU !"
      UNTIL INKEY(-67)
      END
    

Notez qu'en pressant chaque touche, il est possible que plusieurs messages soient générés parce que le programme teste chaque touche de nombreuses fois chaque seconde – et pas une fois seulement – chaque fois qu'une touche est maintenue enfoncée. Vous pouvez essayer aussi d'enfoncer en même temps la  Flèche gauche (←)  et la touche Feu (dans ce cas, la barre d'espacement) pour voir si cela fonctionne.

La ligne pause%=INKEY(1) a deux fonctions :
• elle empêche le programme d'« accaparer » le processeur de l'ordinateur (ce qui peut ralentir d'autres programmes ou épuiser la batterie d'un ordinateur portable plus rapidement), et
• elle empêche la mémoire tampon du clavier (le « buffer » du clavier – voir plus bas) de se remplir si vous appuyez sur les touches à plusieurs reprises. Si la mémoire tampon se remplit, l'ordinateur se plaindra en émettant des bips.

Le buffer (mémoire tampon) du clavier

Le BASIC acceptera que des touches soient pressées à tout moment, et pas seulement quand vous le souhaitez avec INPUT, etc. Pour s'assurer qu'aucune frappe au clavier n'est manquée, il y a une petite file d'attente dans laquelle sont insérées toutes les interventions au clavier. Quand le BASIC utilise INKEY ... GET$, etc. il n'inspecte pas directement le clavier, mais il insère la première entrée trouvée dans cette file d'attente ou buffer, comme on l'appelle généralement. Si vous tapez une touche quand un programme ne s'y attend pas, cette frappe est ajoutée au buffer et y reste jusqu'à ce qu'arrive le prochain GET ou le prochain INKEY, etc. ; là, le caractère est lu. Comme résultat de cette opération, la touche obtenue n'est peut-être pas la touche que vous attendiez : cela dépend des choses inutiles, provenant d'utilisations précédentes, qui peuvent rester dans la mémoire tampon du clavier.

Il est très utile de pouvoir vider le buffer comme on le veut avant d'appeler GET ou INKEY. Tout ce qu'il faut faire, c'est une boucle jusqu'à ce que INKEY ne renvoie rien :

      REPEAT UNTIL INKEY(0)=-1 
    

Comme démonstration, exécutez le petit programme suivant.

      REM Buffer du clavier
      PRINT "Appuyez sur une touche pour continuer"
      A%=GET
      PRINT "Ok. - Tapez-en une autre très vite"
      WAIT 500
      PRINT "Appuyez sur une touche pour continuer"
      REM REPEAT UNTIL INKEY(0)=-1
      A%=GET
      PRINT "Programme terminé"
      END
    

Si vous tapez une touche deux fois avant l'expiration du délai de 5 secondes (ligne 5) la frappe est ajoutée au buffer et y reste. Le prochain appel de GET, à la ligne 8, la lit alors directement sans attendre et le programme se termine. Ôtez le mot REM à la ligne 7 et réessayez. Maintenant, le buffer est vidé avant le deuxième appel, aussi tout va bien.

On pourrait avoir l'impression que c'est beaucoup de complications pour quelque chose d'aussi insignifiant, mais à moins que vous n'en soyez averti, ça vous fera trébucher un jour, aussi vous m'en serez reconnaissant. Honnêtement.

Exercices

13.1
Modifiez le programme de filtrage des nombres pour qu'il accepte une (et seulement une) virgule décimale (= point décimal) dans le nombre.
  Si vous vous sentez de l'ambition, ajoutez une modification supplémentaire pour intercepter la touche  Espace arrière et effacer le dernier caractère de la chaîne, s'il existe.
  Vous devrez imprimer une espace après la chaîne pour effacer le caractère de l'écran.
  [Note : le mot « espace » est féminin en typographie].

13.2
Faites un programme simple de dessin. Utilisez X% et Y% dans une instruction TAB pour dessiner un « X » sur l'écran.
  Lorsque vous pressez les touches fléchées, ajustez X% ou Y% en fonction de la touche pressée.
  Par exemple, si vous pressez la touche  Flèche gauche (←) , diminuez X% ;  pour la touche  Flèche en bas (↓) , augmentez Y%.
  Affichez un « X » à la nouvelle position de façon à laisser une trace sur l'écran.
  Restreignez la zone dans laquelle vous pouvez dessiner à une grille de 20 * 20.

Fin du Chapitre 13