Guide Tutoriel de BBC BASIC for Windows, Ch. 15

Chapitre 15 — Données groupées en structures

Les tableaux, ou matrices, sont une façon merveilleuse d'organiser les données. Dans vos programmes, vous en rencontrerez de nombreuses utilisations. Un jour, il se peut que vous tombiez sur une situation comme la suivante. Supposez que vous écrivez un jeu où vous devez détruire des cibles. Le joueur a plusieurs variables qui lui sont associées : la coordonnée x, la coordonnée y, le nombre de vies et son nom. Vous pourriez aisément définir plusieurs variables comme ceci :

      
      JoueurX%=5
      JoueurY%=12
      JoueurVies%=3
      JoueurNom$="GR8"
      
    

Ou bien, vous pourriez utiliser un tableau pour les trois premières variables et vous souvenir que l'indice 1 représente la position x , le 2 la position y et le 3 le nombre de vies. JoueurNom$ est un problème : il devrait rester une chaîne individuelle.

BBC BASIC offre la capacité de créer votre propre « super » variable qui va regrouper toutes ces variables individuelles ensemble dans un même endroit et par là même, les rendra plus faciles à retrouver. Ce procédé s'appelle une structure, comme vous l'avez probablement deviné à partir du titre de cette partie. Pour déclarer une structure, vous vous servez de DIM, comme pour un tableau, mais avec  l'Accolade ouvrante ( { )  et  l'Accolade fermante ( } )  au lieu de parenthèses ordinaires, de telle sorte que le BASIC sache que nous sommes en train de parler d'une structure. Dans les accolades, on met le nom des variables que nous voulons inclure dans ce groupe. Les règles de dénomination habituelles s'appliquent. Voyons un exemple :

      DIM Joueur{X%,Y%,Vies%,Nom$}
    

Nous pouvons accéder à chacune des variables et les utiliser pour faire tout ce qui est normalement possible avec. La structure ne se comporte que comme un mécanisme de regroupement. L'accès se fait par le nom de la structure (Joueur dans notre cas) suivi d'un point et du nom de la variable que nous désirons. Pour changer le nombre de vies lorsqu'un joueur est touché, nous ferions ceci :

      Joueur.Vies%=Joueur.Vies%-1
      IF Joueur.Vies%<=0 THEN PRINT "FIN DU JEU"
    

Le jargon officiel, ici, est :

      NomDeLaStructure.NomDuMembre
    

Ainsi, vous pouvez déclarer de jolies petites unités pour conserver toutes vos variables dans des groupes logiques. Mais il y a encore mieux. Vous saviez que j'allais dire ça, hein ? Les membres d'une structure ne sont pas limités à des variables uniques. Vous pouvez avoir un tableau comme membre d'une structure. Supposez que votre joueur puisse posséder jusqu'à 10 objets comme équipement : lance-flammes sous-marin, chaussures anti-gravité, etc. Il vous faut une façon de représenter le fait qu'il a ou non récupéré chacun de ces objets. Fabriquons un tableau nommé Objets%. Voici comment nous déclarerions maintenant la structure :

      DIM Joueur{X%,Y%,Vies%,Nom$, Objets%(10)}
    

L'accès se fait comme auparavant :

      IF Joueur.Objets%(5)=TRUE THEN
      PRINT "Vous avez les bottes de cent lieues"
      ENDIF
    

De la même façon, on peut avoir une autre structure comme membre de la structure. Par exemple, il est très courant (surtout dans les programmes Windows™) de faire une structure pour conserver les coordonnées X et Y. C'est ainsi que l'on fait :

      DIM Joueur{Posn{X%,Y%},Vies%, \ 
      \          Nom$, Objets%(10)}
    

Posn (mis pour « position ») est appelé « sous-structure » et on accède à ses composants ainsi :

      Joueur.Posn.X% = Joueur.Posn.X% + 5
    

Les sous-structures peuvent contenir d'autres sous-structures, des variables et des tableaux combinés de toutes les façons possibles. L'idée de base, dans ce cas, est bien sûr de répartir les données en groupes logiques faciles à manipuler, et non de montrer combien vous êtes malin en imbriquant 10 niveaux de données dans 10 niveaux de données.

Tableaux de structures

Quand notre joueur a atteint la fin du jeu, victorieux et sanguinolent, nous souhaiterions ajouter un affichage des meilleurs scores pour qu'il puisse se vanter auprès de ses amis. Le tableau contiendra les 10 meilleurs résultats. À présent, il devrait sembler évident de voir comment cela est fait :

      DIM TabloScore{Nom$,Score%}
    

Parfait, mais cela ne tient compte que de la première position ; nous voulons un tableau. Voici comment on déclare un tableau de structures :

      DIM TabloScore{(10) Nom$,Score%}
    

Le premier élément dans la liste de variables est le nombre d'éléments dans des parenthèses. Cela nous donne une matrice appelée TabloScore qui a 11 structures de 0 à 10. Pour afficher le contenu du tableau des meilleurs scores, nous accédons au tableau ainsi :

      FOR I% = 1 TO 10
        PRINT I%,TabloScore{(I%)}.Nom$;
        PRINT TabloScore{(I%)}.Score%
      NEXT I%
    

Il faut entourer l'indice du tableau avec des accolades pour dire au BASIC que vous travaillez avec une structure. Comme avec les tableaux normaux, les tableaux multidimensionnels sont permis et la même règle s'applique en matière de numérotation à partir de l'élément zéro.

Structures prototypes

En retournant à notre jeu hypothétique, nous avons une structure qui contient les extra-terrestres : leur position actuelle, leur état en matière de force, etc. À la fin du niveau arrive le « big-chef-super-coriace-de-fin-de-niveau » que vous devez abattre avant de pouvoir accéder au niveau supérieur. Ce personnage a les mêmes attributs qu'un extra-terrestre ordinaire, mais il n'apparaît pas très sensé de l'inclure avec les simples soldats. Il nous faut créer une autre structure pour lui, avec les mêmes attributs que ses subordonnés, mais qui soit distincte de telle sorte que nous puissions le traiter comme un cas unique. BBC BASIC nous permet d'utiliser une structure déjà définie comme gabarit ou prototype pour une autre structure.

      REM Structures prototypes
      DIM ExtraT{XPosn%, YPosn%, Force%}
 
      REM Définir notre extraterrestre
      ExtraT.XPosn%=50
      ExtraT.YPosn%=627
      ExtraT.Force%=100
 
      DIM SuperBigChef{}=ExtraT{}
      REM Jouons...
    

SuperBigChef aura donc les membres suivants :

      SuperBigChef.XPosn%
      SuperBigChef.YPosn%
      SuperBigChef.Force%
    

Attention à la confusion, ici : au moment où la structure est déclarée, tous les membres de SuperBigChef seront mis à zéro ; seuls les noms des membres de la structure seront copiés, et non leur valeur réelle.

En nous servant de cette technique, il est également possible de déclarer un tableau de la structure spécifiée.

 
      REM Tableaux de structures prototypes
      DIM ExtraT{XPosn%, YPosn%, Force%}
 
      REM Déclarer tout un niveau d'extraterrestres
      DIM GroupeExtraT{(20)}=ExtraT{}
      GroupeExtraT{(0)}.XPosn%=50
      GroupeExtraT{(0)}.YPosn%=627
      GroupeExtraT{(0)}.Force%=100
 
      REM ...
    

La ligne 5 nous fournit 21 (de 0 à 20) petits bougres prêts à être détruits.

Dans une des parties précédentes, nous avions une structure de joueurs dans laquelle était imbriquée une structure de positions. Cette technique peut également être appliquée à des prototypes. Comme exemple, nous pouvons définir la position de notre extra-terrestre en utilisant XPosn% et YPosn%, mais nous pourrions également en faire une structure. De cette façon, chaque fois qu'un événement nous ferait avoir besoin de donner une position, le prototype nous la donnerait déjà toute prête. C'est utile, parce que cela signifie que nous pouvons à tout moment accéder à la position de la même façon, où qu'elle soit trouvée. Voici comment nous ferions :

      REM Structures prototypes imbriquées
      DIM Position{X%,Y%}
      DIM ExtraT{Posn{}=Position{}, Force%}
      DIM Joueur{Posn{}=Position{}, \
      \          Vies%, Nom$, Objet%(10)}
      
      REM Initialisation de notre ExtraT
      ExtraT.Posn.X%=50
      ExtraT.Posn.Y%=627
      ExtraT.Force%=100
      
      REM Initialiser notre joueur
      Joueur.Posn.X%=50
      Joueur.Posn.Y%=627
      Joueur.Vies%=100
      
      REM ...
    

Tout changement effectué dans la structure Position après le codage initial serait instantanément reflété dans les changements effectués dans les structures qui utilisent Position comme prototype. C'est bien, et c'est moins bien. Si le jeu devait être étendu à trois dimensions, nous le déclarerions à nouveau comme ceci :

      DIM Position{X%,Y%,Z%}
    

et aussitôt, à la fois ExtraT et Joueur ont maintenant une autre dimension dans laquelle ils peuvent jouer. (Il vous reste toujours à écrire vous-même le code qui prendra cela en charge. « BB4W » ne peut pas remplacer VOTRE intelligence.) Le point auquel il faut faire très attention, c'est si l'on va dans l'autre sens : si vous ôtez un élément, vous devez aussi ôter toute référence qui lui est faite dans chaque structure qui le contient. Pensez à la disposition de vos données avant de les mettre en place, et vous économiserez ainsi des heures de frustration et de recommencement de votre travail.

Bien évidemment, ces techniques s'appliquent à l'utilisation de structures plus grandes, mais ne perdez jamais de vue le fait que ce ne sont que des façons de rassembler des données similaires pour qu'elles soient toutes accessibles au même endroit. Dès que vous aurez pris le coup en matière de structures, vous vous demanderez comment vous avez jamais pu vous débrouiller sans elles.

Si vous lisez les fichiers d'aide, vous verrez qu'il est possible de faire des merveilles avec les structures, mais la présente introduction vous suffira pour un bon moment encore.

Exercices

15.1
Vous voulez enregistrer les niveaux d'un élève pour cinq matières, ainsi que son prénom et son nom. Pouvez-vous suggérer une structure qui ferait cela ?

15.2
Écrivez un programme qui déclare une telle structure et qui demande les informations. Calculez le niveau moyen et affichez les résultats.

15.3
Si vous aviez 20 élèves dans une classe, comment feriez-vous un tableau à partir de la structure ci-dessus ?

Fin du Chapitre 15