Ça fait plusieurs chapitres que je dis que je vais parler d’AMAL, et le moment est enfin venu. Bien que je l’utilise rarement moi-même, beaucoup de gens le font et ne jurent que par lui. En fait, ce sont souvent les débutants qui aiment AMAL. Les programmes AMOS professionnels ont tendance à l’éviter car il peut causer des problèmes par la suite si un grand programme doit être compilé.
Je vais donc couvrir les bases dans ce tutoriel, puis vous laisser décider. En plus des aspects pratiques, je vais aussi expliquer un peu la théorie d’AMAL. Si vous préférez, vous pouvez passer directement au programme pour le saisir, et ignorer les détails techniques si vous maîtrisez déjà bien AMAL. (Mais si vous connaissez déjà bien AMAL et AMOS en général, que faites-vous encore à lire ce livre ?)
AMAL signifie AMOS Animation Language et c’est l’un des éléments les plus importants d’AMOS. C’est un moyen puissant d’animer des Sprites et des Bobs (ou tout autre objet que vous déplacez à l’écran) sans surcharger le processeur. En effet, les commandes AMAL sont des commandes BASIC optimisées, compilées avant exécution, ce qui les rend très rapides. Vous pouvez intégrer très facilement du code AMAL dans vos programmes AMOS, et voici comment :
La façon la plus simple et la plus accessible d’utiliser AMAL est d’insérer les commandes sous forme de chaînes dans des instructions AMOS, comme ceci :
Amal 1,"s= m 300,200,100 ; M -300,-200,100 J s" Amal On 1
Cela lance le programme AMAL (ou canal) numéro 1. Chaque commande AMAL est une lettre unique, comme M pour Move, A pour Animate et L pour Let. Si vous tapez les lettres complètes du mot, AMAL les ignorera, mais cela facilitera la lecture pour les autres (ou pour vous dans quelques mois). Pour plus de clarté, tapez la lettre initiale en majuscule et le reste en minuscule. Les commandes étant intégrées dans des chaînes, l’ordinateur ne les traitera pas comme les commandes AMOS normales.
AMAL contient des commandes très intelligentes, comme la commande Play (ou PL), qui sert à enregistrer des mouvements de souris (par exemple pour une vague d’attaque) et à les rejouer sur un Sprite. Il existe aussi des commandes pour lire les positions du joystick et de la souris, bien plus rapides que les commandes AMOS classiques, et très utiles pour les jeux d’action rapide ou les programmes graphiques où une lecture rapide de la souris est essentielle.
Si le programme AMAL tient sur une seule ligne, vous pouvez simplement faire :
Amal 8,"programme"
Mais si votre programme utilise plusieurs lignes, vous devez ajouter chaque ligne à une variable, puis attribuer cette variable à AMAL. C’est ce que font la plupart des programmes AMAL. Exemple :
C$="For R=0 To 10 ;" C$=C$ + "For RO=1 To 320 ; Let X=X+1 ; Next RO ;" C$=C$ + "Let Y=Y+8 ;" Amal 8,C$ : Amal On 8
Écrire Amal 8,C$ revient à dire « Amal 8, insère ton programme ici », et la ligne Amal On 8 exécute ce programme.
Les commandes AMAL sont bien moins nombreuses que celles d’AMOS, mais elles permettent tout de même de faire beaucoup de choses, notamment pour les jeux. L’ensemble des commandes se divise en deux catégories : les commandes et les fonctions.
M)A)L)J)I)P / T / N)PL)P)AU)X)W)O)D)Il existe 15 fonctions AMAL, qui sont des méthodes simples pour obtenir des informations à partir de l’écran, du joystick et de la souris. Ces fonctions seront détaillées dans la suite du chapitre.
Voici la liste des fonctions AMAL, connues sous le nom de Table 12.2. Elles permettent d'obtenir rapidement des données depuis la souris, le joystick, l'écran ou encore les collisions d'objets.
| Commande | Action |
|---|---|
| =XM | renvoie la coordonnée X de la souris |
| =YM | renvoie la coordonnée Y de la souris |
| =K1 | état du bouton gauche de la souris |
| =K2 | état du bouton droit de la souris |
| =J0 | test du joystick droit |
| =J1 | test du joystick gauche |
| =XH | convertit une coordonnée X en coordonnée matérielle |
| =YH | convertit une coordonnée Y en coordonnée matérielle |
| =XS | convertit une coordonnée X matérielle en coordonnée écran |
| =YS | convertit une coordonnée Y matérielle en coordonnée écran |
| =BC | teste les collisions entre Bobs |
| =SC | teste les collisions entre Sprites |
| =C(n) | renvoie l'état de l'objet n après un test de collision avec =BC ou =SC |
| =Z(n) | génére un nombre aléatoire entre 0 et n |
| =V(v) | fonction VU mètre, voir ci-dessous |
Deux des fonctions ne rentrent dans aucune catégorie : la fonction de VU mètre et celle de nombre aléatoire. Il faut bien dire qu’AMOS est probablement le seul langage au monde à inclure une fonction de VU mètre en natif !
La fonction de VU mètre est utile pour créer des indicateurs de niveau audio (ces jolis vumètres animés que l’on voit sur les chaînes hi-fi) dans vos démos musicales. Vous pouvez ainsi faire bouger des Sprites ou des graphismes de haut en bas ou de gauche à droite en rythme avec la musique.
Tout le monde n’a pas besoin de VU mètres, mais tout le monde a besoin de nombres aléatoires à un moment donné. Bien sûr, vous pouvez les générer en AMOS et les passer à AMAL, mais vous obtiendrez de bien meilleurs (et plus rapides) résultats en utilisant la fonction =Z(x), où x est la plage numérique. Par exemple, =Z(255) renverra une valeur comprise entre 0 et 255.
Si vous prévoyez d’imprimer votre programme dans un magazine ou de le partager avec des amis, intégrer le code AMAL directement dans vos listings AMOS est une bonne méthode. Mais si vous êtes le seul à voir ce code, par exemple si vous prévoyez de compiler ou de protéger votre programme, alors l’éditeur AMAL est préférable.
L’éditeur AMAL prend vos programmes AMAL et les place dans une banque mémoire. Vous pouvez ensuite appeler ces programmes AMAL à partir de cette banque, ce qui permet d’économiser de l’espace dans votre programme AMOS et empêche quiconque d’inspecter votre code.
Je reviendrai sur l’éditeur AMAL en détail au chapitre 13.
Le principal avantage des commandes AMAL par rapport aux commandes AMOS classiques est qu'elles sont compilées, et donc s'exécutent beaucoup plus rapidement que les commandes équivalentes en langage AMOS standard. Elles sont donc idéales pour animer vos sprites.
Pour déplacer un sprite, vous utilisez le format suivant :
M w,h,n
où w correspond au nombre de pixels horizontalement, h au nombre de pixels verticalement, et n correspond à la vitesse du mouvement. Par exemple :
M 75,75,100
effectue un déplacement très lent de 75 pixels vers la droite et vers le bas. Ainsi, si le sprite démarre à la position 100,100, il se retrouvera à 175,175. Si vous effectuez ensuite un déplacement comme celui-ci :
M 0,-75,20
il s'agira d'un déplacement très rapide vers le haut. Des valeurs négatives pour w et h permettront des déplacements vers la gauche et vers le haut. Le sprite serait donc à présent en 175,100.
La vitesse du mouvement est régie par la valeur n, c'est-à-dire le nombre d'étapes du mouvement. Évidemment, si vous avez beaucoup d'étapes, le déplacement sera lent et précis. Si vous avez très peu d'étapes, le déplacement sera rapide.
Animer des sprites est simple avec AMAL, et c'est d'ailleurs la spécialité d'AMAL, la raison pour laquelle les commandes sont compilées avant l'exécution.
L'animation est généralement très lente car l'ordinateur doit effectuer beaucoup d'opérations. Mais avec AMAL, les animations fonctionnent indépendamment du reste du programme AMOS.
La commande d'animation est représentée par une seule lettre A, et le format est le suivant :
A n,(x,y)(x,y)
où n représente le nombre de fois que l'animation se répète, et x,y représentent respectivement le numéro de l'image et sa durée. Un zéro pour le nombre de cycles signifie que l'animation tourne en boucle indéfiniment.
Par exemple :
A 0,(1,4)(2,4)(3,4)(4,4)(5,4)
crée une animation continue avec cinq images, chacune affichée pendant une durée de 4. Le numéro de l'image d'animation correspond au numéro du sprite dans la banque de sprites.
Pour démarrer vos programmes AMAL, même s'ils ont été chargés depuis un fichier .abk, vous devez utiliser la commande Amal On. Vous pouvez spécifier un numéro de programme AMAL comme ceci :
Amal On 8
ou bien ne rien spécifier pour exécuter tous les programmes AMAL actuellement en mémoire :
Amal On
Par défaut, les programmes AMAL que vous lancez affectent un Sprite matériel portant le même numéro, bien que cela puisse être modifié avec la commande Channel. Mais dans la situation par défaut, voici comment cela fonctionne :
Amal On 2
active une animation impliquant le Sprite matériel numéro 2.
Comme en AMOS normal, les programmes AMAL peuvent utiliser des étiquettes pour marquer certains points du programme, vers lesquels on peut sauter grâce à la commande Jump (ou J). Pour définir une étiquette, tapez-la simplement suivie de :, comme ceci :
Start: A 0,(1,4)(2,4)(5,4)(4,4)(5,4) M 0,-75,20
Maintenant, à n'importe quel moment du programme, vous pouvez sauter à ce point en utilisant :
Jump Start
Les étiquettes peuvent être n'importe quoi, mais c'est la première lettre qui compte, comme dans toutes les opérations AMAL. Donc pour étiqueter le programme, vous auriez tout aussi bien pu écrire :
S: A 0,(1,4)(2,4)(3,4)(4,4)(5,4) M 0,-75,20
et pour sauter à ce point du programme :
J S
AMAL est un peu déroutant de ce point de vue. Cela peut sembler très compliqué et technique de n'utiliser que les mots-clés AMAL sous forme de lettres uniques, mais je trouve qu'il est utile de les compléter avec des lettres minuscules pour les rendre plus lisibles, même pour des commandes très fréquentes comme Move et Anim. Évidemment, chacun est libre de faire comme il l'entend.
Et qu'est-ce que cela donne ? Un petit programme AMAL, voilà ce que c'est. Vous pouvez soit écrire le programme comme ceci dans l'éditeur AMAL sur le canal 8 :
Anim 0,(1,3)(2,3)(3,3)(4,3) Move 0,75,50 Move 75,0,50 Move 0,-75,50 Move -75,0,50
en prenant soin de charger et positionner le Sprite 8 en premier bien sûr. Ou bien vous pouvez le faire directement en AMOS comme ceci :
Rem * Simple AMAL Anim.AMOS * Rem * C'est encore l'heure de la pieuvre * Rem Load "AMOS_DATA:Sprites/Octopus.abk" Get Sprite Palette Sprite 8,100,100,1 M$="Anim 0,(1,3)(2,3)(3,3)(4,3)" M$=M$+"Move 0,75,50" M$=M$+"Move 75,0,50" M$=M$+"Move 0,-75,50" M$=M$+"Move -75,0,50" Amal 8,M$ : Amal On 8
Évidemment, vous pouvez utiliser vos propres Sprites (produits avec SpriteX, peut-être ?) au lieu de ceux fournis sur la disquette. Je sais que si je vois encore cette fichue pieuvre, je vais crier.
Vous pouvez non seulement déplacer des Sprites mais aussi des écrans entiers. Ce programme fait rebondir un écran. La répétition de l'effet est gérée par une série de boucles, toutes reliées à des étiquettes. Essayez de suivre où le programme se dirige à tout moment, et comment le flux du programme change au fur et à mesure des événements :
Rem * Screen Bounce.AMOS *
Rem
Channel 0 To Screen Display 0
Channel 1 To Screen Offset 0
F$=Fsel$("","","Choisissez une image")
Load Iff F$,0
A$="Boing:Let Y=-256"
A$=A$+"Let R0=256"
A$=A$+"Let R1=8"
A$=A$+"Let R2=45"
A$=A$+"Move 0,R2-Y,R1"
A$=A$+"Loop:Move 0,R2-Y-R0,R1"
A$=A$+"Move 0,R2-Y,R1"
A$=A$+"Let R0=R0/2"
A$=A$+"Let R1=R1-1"
A$=A$+"If R0 Jump Loop"
A$=A$+"For R0=0 To 25"
A$=A$+"Pause"
A$=A$+"Next R0"
A$=A$+"Move 0,320,50"
A$=A$+"Let RA=HA+1"
A$=A$+"Jump Boing"
B$="Boing:Let X=0"
B$=B$+"Let R3=RA"
B$=B$+"Let R0=320"
B$=B$+"Let R1=10"
B$=B$+"Move 0-X,0,R1"
B$=B$+"Loop:Move 0-X+R0,0,R1"
B$=B$+"Move 0-X,0,R1"
B$=B$+"Let R0=R0/2"
B$=B$+"Let R1=R1-1"
B$=B$+"If R0 Jump Loop"
B$=B$+"Sync:"
B$=B$+"If RA=R3 Jump Sync"
B$=B$+"Jump Boing"
Amal 0,A$
Amal 1,B$
Amal On
Direct
La dernière commande signifie que la fenêtre du mode Direct est activée, ce qui vous permet de taper :
Amal Off
si vous le souhaitez, pour arrêter le mouvement. C'est rapide, n'est-ce pas ? Vous pouvez aussi faire en sorte que la routine s'arrête en ajoutant une commande Mouse Key et ensuite en appelant Amal Off.
Les mots Loop, Boing, et Sync sont tous des étiquettes, pas des commandes. La commande Jump vous fait passer d'une petite routine à une autre un grand nombre de fois, et parce qu'AMAL est compilé, le mouvement est très rapide, presque une vibration plutôt qu'un tremblement. Essayez de modifier le programme pour faire en sorte que l'écran rebondisse à gauche ou à droite aléatoirement comme s'il était en caoutchouc.
Une version plus manuelle de la même blague, qui peut vous être utile un jour (mais Dieu sait à quoi), est cette astuce de capture d'écran. L'idée est simplement que vous cliquez sur l'écran et ensuite vous pouvez le déplacer comme s'il était attaché au pointeur de la souris. J'imagine que si l'écran était un super-bitmap (c'est-à-dire plus grand que l'écran), vous pourriez cacher le pointeur de la souris et l'utiliser pour permettre à l'utilisateur de faire défiler une grande carte avec la souris. La souris est limitée à une certaine zone de l'écran, donc vous n'avez pas besoin de voir où se trouve le pointeur.
(L'écran que je charge ici est AMOSPIC.IFF de votre disquette de données AMOS, mais n'importe quel écran fera l'affaire.)
Rem * Screen Grabber.AMOS * Rem Load Iff "df0:iff/AMOSPIC.iff",1 Screen Display 0,,,320,200 Channel 0 To Screen Display 1 Limit Mouse 130,50 To 320+130,50+255 Amal 0,"Loop: Pause; If K1=0 Jump Loop; Let Y=YM-128; If XM-160<64 Jump Loop; Let X=XM-160; Jump Loop" Amal On Screen 0 Repeat Until Inkey$<>""
Pour arrêter l'effet vous devez appuyer sur la barre espace ou une autre touche : REPEAT UNTIL INKEY$<>"" est une bonne façon de scruter une touche tout en laissant un autre processus tourner, en particulier les programmes AMAL qui continueront tant qu'ils ne sont pas stoppés par AMAL OFF.
Pour voir jusqu'où vous pouvez pousser AMAL, pourquoi ne pas remplir l'écran de Bobs ? Imaginez la pire vague d'attaque de vos rêves, avec des centaines d'aliens gigotants sur tout l'écran. Vous pouvez vraiment mettre la pression aux joueurs si vous suivez ce programme. Il prend un Bob à partir d'un fichier ABK, l'anime et le déplace dans les limites de l'écran, puis active une série d'autres Sprites via une boucle, et remplit l'écran de bestioles frétillantes. (Jeff Minter en serait fier ! petit clin d'oeil pour les fans de jeux C64.)
Il y a normalement une restriction sur le nombre de programmes AMAL (et donc d'événements) que vous pouvez faire tourner, mais il existe une astuce simple si vous voulez vraiment aller loin. Encore une fois, ce programme utilise la pieuvre que François avait incluse sur ses disquettes originales, mais seulement parce qu'elle est plus jolie.
Rem * Amal Madness.AMOS * Rem Screen Open 0,320,200,8,Lowres Load "df0:sprites/octopus.abk" Cls 0 Double Buffer : Flash Off : Fade 4 To -1 Synchro Off A$="Anim 0,(1,1)(2,1)(3,1)(4,1);" A$=A$+"Update: Let R0=Z(255)+Z(63)-X; Let R1=Z(127)+Z(63)-Y; Let RZ=Z(15)+4;" A$=A$+"Move R0,R1,RZ; Jump Update" For I=0 To 63 Set Bob I,1,%111, Bob I,Rnd(320)+1,Rnd(200)+1,Rnd(3)+1 Channel I To Bob I Amal I,A$ Next I Amal On Repeat Synchro : Wait Vbl Until Mouse Key
L'astuce est réalisée avec Synchro, utilisée ici pour dépasser la limite normale de 16 programmes AMAL actifs simultanément. Il suffit d'utiliser Synchro Off avant de définir vos programmes AMAL, comme dans cet exemple. Ensuite vous pouvez utiliser des numéros de canal AMAL supérieurs à 15 sans provoquer d'erreur.
Un point intéressant est que les déplacements des Sprites sont randomisés avec la fonction =Z(x) pour fournir des valeurs aléatoires dans la commande Move, donc toutes les valeurs X, Y et de pas sont générées en temps réel. Il est donc impossible de prévoir où iront ces petits monstres.
Le contrôle des animations AMAL doit se faire soit par le joystick, soit par la souris. Soyons honnêtes, si vous animez un Sprite quelconque, vous voudrez probablement le déplacer, et ce sont les deux seules façons de le faire.
Utiliser le joystick est idéal pour les jeux, et le lire depuis AMAL est très facile, en fait bien plus simple qu'avec AMOS lui-même. Cet exemple de programme utilise le singe armé d'une mitrailleuse issu des disquettes de démo :
Rem * AMAL Joystick.AMOS * Rem Rem * N'oubliez pas de charger un fichier sprite.abk * Rem * celui appelé MONKEY_RIGHT.ABK est le meilleur * Rem Curs Off : Flash Off : Hide : Cls 0 Double Buffer Get Sprite Palette A$="Begin:" A$=A$+"If J1&4 then Jump G ;" : Rem joy gauche A$=A$+"If J1&8 then Jump H ;" : Rem joy droite A$=A$+"If J1&2 then Jump P ;" : Rem joy haut A$=A$+"If J1&1 then Jump O ;" : Rem joy bas A$=A$+"Jump Begin ;" A$=A$+"H: Anim 1,(1,4)(2,4)(3,4)(2,4)(1,4) ; Move 16,0,16 ; Jump Begin ;" A$=A$+"G: Anim 1,($8001,4)($8002,4)($8003,4)($8002,4)($8001,4) ; Move -16,0,16 ; Jump Begin ;" A$=A$+"P: Anim 1,(1,4)(2,4)(3,4)(2,4)(1,4) ; Move 5,16,16 ; Jump Begin ;" A$=A$+"O: Anim 1,($0001,4)($0002,4)($000A,4)($0002,4)($0001,4) ; Move -5,-16,16 ; Jump Begin ;" Bob 1,100,100,1 Channel 1 To Bob 1 Amal 1,A$ Amal On Direct
La direction dans laquelle le Sprite est orienté dépend entièrement de la façon dont il a été dessiné, mais les directions sont lues à partir du stick grâce à la fonction J1. En utilisant l'opérateur AND avec l'entrée de J1, vous obtenez la direction dans laquelle le joystick est orienté.
Une fonctionnalité intéressante de ce programme à noter est que si vous ajoutez $800 devant le numéro d'image d'un Bob, vous le retournez horizontalement. Cela fonctionne pour tous les types de Sprites et de Bobs, et c'est très pratique car vous n'avez besoin de dessiner le Sprite que dans une seule direction. Il faut seulement veiller à ce que le Sprite soit visuellement cohérent dans les deux sens, bien que pour la plupart des Sprites cela ne se remarque pas.