Sponsors

FacebookTwitterGoogle Bookmarks

La rubrique « Transactor », qui débute dans ce numéro de l’Amiga News-Tech, nous a été inspirée par notre confrère canadien « Transactor for the Amiga », un journal fait par des programmeurs de tous niveaux, pour des programmeurs de tous niveaux. La formule est simple : tout programmeur, quelque soit le type d’application qu’il développe (jeux, utilitaires, etc.) et le langage qu’il utilise (C, assembleur, Pascal, etc.), possède des trucs qui lui sont propres, ou bien une excellente connaissance d’un sujet précis. Notre but est qu’il en fasse profiter les autres, afin que se crée entre les programmeurs de France et de Navarre une sorte de « chaîne de l’amitié », où tout le monde pourrait parler de ce qui lui tient à coeur. Une sorte de domaine public sur papier. Cette série démarre avec et ce n’est que justice la traduction d’un article de John Toebes paru dans le numéro de Juin Juillet 88 de « Transactor for the Amiga ». Il vous donnera un excellent aperçu de ce que nous voulons faire. Les intéressés qui désireraient collaborer à la rubrique « Transactor » peuvent envoyer leur article sauvegardé en ASCII sur disquette Amiga ou PC, accompagné d’un petit C. V. qui permettra aux lecteurs de les situer. Si l’article doit comporter des listings, il serait judicieux d’y adjoindre le fichier source, également en ASCII. Tout ce qui concerne la programmation sur Amiga sera le bienvenu, et tout le monde peut participer, depuis le bidouilleur fou paumé au fin fond de sa campagne jusqu’au programmeur professionnel, en passant par les clubs d’utilisateurs, etc. Alors en attendant de lire votre prose dans ces pages, appréciez donc celle de John Toebes ! IL A LA FORMULE... (air connu) Ça ne se verra peut-être pas du premier coup d’œil, mais à partir de ce numéro et jusqu’à dorénavant, Iamiga News-Techs change quelque peu de formule, pour devenir ¦ un véritable cahier détachable à l’intérieur de Commodore Revue.

Click image to download PDF

AMIGA NEWS TECH numero 04 (09-1989)

Document sans nom SOMMAIRE
EDITO
Edito : Il a la formule...
ExecBase : Transactor is good for you !
Transactor : comment optimiser vos programmes en assembleur, par John Toebes L’assembleur 68000 : douzième épisode, par Max Tube-lntro : le scrolling dans tous les sens et le ciel étoilé, par Little Zeus
Initiation à Pamiga-Basic : les boucles et les sauts, par Michel Descoins AmigaDOS Minimum :?????
Trucs & Astuces AmigaDOS : après le minimum, le maximum que vous puissiez tirer de PamigaDos, par Phantasia
Les Rescues de Little Zeus : tout ce qu’il faut être un vainqueur, par Little Zeus ViewPort : Eagle’s Rider de Microïds Requester : vos problèmes techniques sur Amiga enfin résolus !
Les rubriques déjà en place dans l’Amiga News- Tech ne changent pas. Par contre, d’autres viennent s’y ajouter :
« Transactor », une rubrique d’un genre nouveau en France, qui, nous l’espérons, vous intéressera vivement ;
« Trucs & Astuces AmigaDOS », qui vous dévoilera la face cachée du système d’exploitation de l’Amiga, tout en complétant efficacement « L’AmigaDOS Minimum » ;
« Les rescues de Little Zeus », notre docteur es Cop- perList maison ;
« ViewPort », un regard indiscret sur les logiciels en cours de développement chez les éditeurs.
Toutes ces nouvelles rubriques, dont certaines ne pourront malheureusement pas être régulières, ont entraîné une augmentation du nombre de pages de l’Amiga News Tech, qui en compte désormais 24. De quoi s’éclater comme des fous sur Amiga !
Stéphane Schreiber
ExecBase
TRANSACTOR IS GOOD FOR YOU !
La rubrique « Transactor », qui débute dans ce numéro de l’Amiga News-Tech, nous a été inspirée par notre confrère canadien « Transactor for the Amiga », un journal fait par des programmeurs de tous niveaux, pour des programmeurs de tous niveaux.
La formule est simple : tout programmeur, quelque soit le type d’application qu’il développe (jeux, utilitaires, etc.) et le langage qu’il utilise (C, assembleur, Pascal, etc.), possède des trucs qui lui sont propres, ou bien une excellente connaissance d’un sujet précis.
Notre but est qu’il en fasse profiter les autres, afin que se crée entre les programmeurs de France et de Navarre une sorte de « chaîne de l’amitié », où tout le monde pourrait parler de ce qui lui tient à coeur. Une sorte de domaine public sur papier.
Cette série démarre avec et ce n’est que justice la traduction d’un article de John Toebes paru dans le numéro de Juin Juillet 88 de « Transactor for the Amiga ». Il vous donnera un excellent aperçu de ce que nous voulons faire.
Les intéressés qui désireraient collaborer à la rubrique « Transactor » peuvent envoyer leur article sauvegardé en ASCII sur disquette Amiga ou PC, accompagné d’un petit C. V. qui permettra aux lecteurs de les situer. Si l’article doit comporter des listings, il serait judicieux d’y adjoindre le fichier source, également en ASCII.
Tout ce qui concerne la programmation sur Amiga sera le bienvenu, et tout le monde peut participer, depuis le bidouilleur fou paumé au fin fond de sa campagne jusqu’au programmeur professionnel, en passant par les clubs d’utilisateurs, etc.
Alors en attendant de lire votre prose dans ces pages, appréciez donc celle de John Toebes !
IL A LA FORMULE... (air connu)
Ça ne se verra peut-être pas du premier coup d’œil, mais à partir de ce numéro et jusqu’à dorénavant, Iamiga News-Techs change quelque peu de formule, pour devenir ¦ un véritable cahier détachable à l’intérieur de Commodore Revue. Les programmeurs etbu hobbyistes que vous êtes pourront ainsi s'y retrouver plus facilement.
Les plus attentifs d’entre vous auront certainement remarqué qu’il n’y avait pas de Tube-lntro dans notre dernier numéro. Qu’à celà ne tienne, voici de quoi nous rattraper, avec carrément 5 pages ! Ne venez plus nous dire après ça qu’on ne vous bichonne pas...
Tube-lntro de Little Zeus
Nous nous retrouvons une fois de plus pour aborder, en cette fin d’été, la dernière partie de la seconde phase de l’unique et resplendissante Tube-lntro.
Après la Tube-intro, selon vos désirs, nous pourrons soit nous lancer dans la réalisation d’une nouvelle intro, soit créer un contact lecteurs Little Zeus, qui vous permettrait, chaque mois, de formuler des requêtes de routines ; par exemple si vous planchez sur animation au moyen du Blitter ou sur une quelconque routine utile à une de vos démos, faites-en part au journal et vos désirs seront comblés. A condition, bien entendu, que le programme soit d’un intérêt certain pour l’ensemble des lecteurs.
Regardez bien les pages qui suivent : nous publions ce mois-ci près de 250 lignes de programme (dont les commentaires sont assez explicites pour qu’il ne soit pas utile de revenir précisément sur chaque point de la routine), à la suite de quoi nous aurons simultanément à l’écran la déformation du logo et le scrolling de texte. Il ne restera plus alors que la routine créant un défilement de plusieurs champs d’étoiles à vitesses différentes, routine pouvant être utilisée seule ou bien au sein de n’importe quelle démo de votre choix.
RÉSUMÉ DE L’ÉPISODE PRÉCÉDENT
Je rappelle aux cancres qui dormaient au fond de la classe que nous avions commencé à expliquer le fonctionnement du scrolling des caractères qui, je le rappelle également, se déplaçait de droite à gauche (c’est plus pratique pour lire le message...), pouvait monter et descendre (rebonds) et tourner sur lui-même soit vers le haut, soit vers le bas (effet de rouleau). Relisez bien l’article précédent afin d'aborder celui-ci dans les meilleures conditions.
Nous avions laissé en suspend la question de la « non-superposition » des deux playfields. Ayant de savoir pourquoi le playfield avant est décalé de 16 pixels sur la droite, il faut comprendre qu’afin de donner l’impression d’avoir des caractères gravés sur un rouleau, nous avons créé un effet d’ondulation courbe vers la droite pour les caractères du playfield avant
et vers la gauche pour les caractères du playfield arrière. Etant bien entendu que l’Amiga, malheureusement limité, ne peut subir un décalage de bitplane supérieur à 16 pixels et ce uniquement vers la droite, nous sommes confrontés à un problème, heureusement soluble, lorsque nous souhaitons créer un effet de courbe vers la gauche.
Nous allons donc user d’un subterfuge : en affichant le playfield avant décalé de 16 pixels sur la droite par rapport au playfield arrière, nous sommes en mesure, en décalant les bitplanes du playfield arrière vers la droite, de simuler un effet de courbe vers la gauche. Peut-être celà semble-t-il quelque peu illogique ou compliqué ? Reportez-vous donc aux figures ci-jointes pour mieux comprendre.
COMMENT ÇA MARCHE ?
Après la théorie, découvrons la pratique. En fait, vous l’avez peut-être deviné, nous allons utiliser quoiqu’un peu modifié mais le principe est le même le procédé qui nous permettait de déformer notre logo latéralement : nous changeons la valeur de décalage des bitplanes à chaque ligne (je ne réexplique pas, pour plus de précisions, reportez-vous à l’article correspondant). La différence est minîme : alors que pour la déformation du logo, nous modifiions perpétuellement les décalages bitplane afin de créer un effet de « vagues », dans la routine de ce mois-ci, nous devons garder la forme courbée constante au cours du temps. De plus, lorsque le tube se déplace verticalement. Nous devons changer l’emplacement de l’écran sur lequel créer le décalage. Nous recourons donc à une sous-routine intervenant directement dans la CopperList et dont le rôle est de recalculer, à chaque décalage vertical du rebond, l’adresse de la première ligne sur laquelle nous devons décaler les bitplanes. Facile, non ? (NDLR : Non !.
Les effets de couleurs sur le tube fonctionnent de manière analogue. Les couleurs sont utilisées pour renforcer l’effet de perspective du tube. De la même manière qu’il est obligatoire de repointer dans la CopperList l’emplacement à partir duquel nous désirons l’effet de courbure, il est nécessaire d’en faire autant pour l’effet des couleurs.

L’OBSËDÉ TEXTUEL
Il ne reste plus maintenant qu’à afficher les caractères. Le texte du scrolling est défini par le programmeur. La routine autorise même l’insertion de codes de contrôle, qui permettent d’influencer le déroulement, si j’ose dire, du scrolling.
A propos, vous pouvez remarquer que nous utilisons un ScrollRaster en diagonale pour le playfield arrière, alors que nous en utilisons deux, un vertical suivi d’un horizontal, pour le playfield avant, ce qui apparemment est équivalent. Nous nous « encombrons » de deux ScrollRaster sur le playfield avant pour la simple et bonne raison que les caractères sont affichés sur ce dernier. Par conséquent, afin de ne pas voir apparaître des caractères déformés, nous les scrol- lons horizontalement vers la gauche jusqu’à ce qu’ils apparaissent sur l’écran visible (rappelez-vous que les caractères sont affichés en dehors de l’écran pour cause d’esthéticité évidente). Ainsi, le caractère apparaît « normalement à l’écran » et peut ensuite, grâce au scrolling vertical, partir diagonalement vers le haut. Si nous avions utilisé un seul ScrollRaster diagonal sur le playfield avant, les caractères auraient apparu déformé.
Une denière petite précision : vous avez certainement remarqué que dans la routine publiée ce mois- ci, il est question « d’autorisation du scrolling vertical de rotation du playfield arrière » (c’est fini, respirez). Ceci correspond à une des options du scrolling, c’est-à-dire qu’il est possible d’arrêter uniquement le scrolling vertical de rotation (alors que d’habitude, les deux scrollings doivent être arrêtés en même temps).
LA FONTE DU SAVOYARD
Il s’agit maintenant de permettre à l’ordinateur de trouver parmi toutes ses données graphiques, celles qui correspondent au caractère que nous souhaitons afficher dans le scrolling. Pour celà, nous avons créé une liste comprenant les addresses de l’ensemble des caractères disponibles (la liste que vous trouvez dans ce programme fait figure d’exemple, libre à vous d’en créer une autre). Notez que cette liste doit absolument inscrire les caractères dans l’ordre dans lequel ils sont affichés dans l’image IFF. Plus concrètement, si dans la liste nous avons « ABC ?. » il faut nécessairement que l’image IFF contienne « A », « B », « C », » ? » et ». » à la suite.
Voyons maintenant comment procède la routine. Le programme a été conçu de telle manière qu’il y ait 8 caractères graphiques par ligne, soit 40 pixels de large par caratère. Nous devons donc repérer le caractère au sein de ces données graphiques ; pour savoir à quelle ligne il appartient, il suffit de diviser le numéro de sa position dans la liste par 8, le dividende correspondant alors au numéro de ligne et le reste à sa position sur cette ligne. Quant à l’affichage, rien de plus simple. Chaque caractère appartenant à deux bitplanes, nous copions les données IFF vers ces deux derniers.
MINITEL
mes annonces ayiH4 -
e o a n o ij
UMKÜV
LES FORUMS AMI G A
ï l*SS? i=_=? F % .
1
36 I 6 OOMHLVj
Les 22u premiers logiciels ï du domaine public r
I rlo I S nnilortifin Lrs H Uiçh
rtLECHAR-
GEMENT1Ü
EH, TOI, L’ÉTOILE...
Afin d’anticiper sur le prochain numéro nous allons dès maintenant étudier le principe des sprites. Effectivement, c’est grâce à eux qu’il nous sera possible d’avoir notre scrolling céleste.
Le sprite est un élément graphique de 16 pixels de large sur une hauteur maximale égale à celle de l’écran. Il comporte normalement 3 couleurs. Lorque nous sommes en mode Dual-Playfield, comme c’est le cas dans la Tube-lntro, il est possible, au moyen de priorités, de les positionner par exemple en avant du Playfield arrière et en arrière du Playfield avant, ou encore en arrière des deux Playfields... L’Amiga n’offre que 8 sprites, mais nous pouvons facilement en afficher bien plus. Une dernière chose avant d’entrer dans les détails : chacun des 8 sprites est autonome, c’est à dire que nous pouvons choisir une priorité indépendante. Cependant, à cause du Hardware, deux sprites consécutifs possèdent les mêmes couleurs (ce qui, dans le cas d’un ciel étoilé, n’est pas trop gênant).
Le petit tableau ci-dessous illustre la façon dont sont colorés les sprites.
Sprites
Données des sprites
Couleur
0 et 1
00
transparent
01
couleur 17
10
couleur 18
11
couleur 19
2 et 3
00
transparent
01
couleur 21
10
couleur 22
11
couleur 23
4 et 5
00
transparent
01
couleur 25
10
couleur 26
11
couleur 27
6 et 7
00
transparent
01
couleur 29
10
couleur 30
11
couleur 31
Pour afficher les sprites à l’écran, il faut créer une liste pour chacun d’entre eux ; ensuite, c’est au moyen du DMA sprite que l’Amiga lira chaque SpriteList. Une liste simple se compose de la manière suivante : deux mots de contrôle, suivis de plusieurs mots de données, puis à nouveau deux mots de contrôle. Le premier ensemble de mots de contrôle spécifie les coordonnées de départ et de fin du sprite, les mots de données contiennent sa définition graphique par bitplane pour chacune de ses lignes, et enfin le second ensemble de mots de contrôle caractérise la fin de la liste.
Pour récapituler tout ça plus clairement, voici le schéma d’une SpriteList simple :
Début liste :
dc. w hstart-vstart,vstop dc.w données 1 de la ligne 1, données 2 de la ligne 1 dc.w données 1 de la ligne 2, données 2 de la ligne 2 ... dc.w données 1 de la ligne n, données 2 de la ligne n dc.w 0,0
Il est possible de créer en tout huit SpriteLists. Cependant, afficher huit sprites à l’écran peut paraître quelque peu restreint. En fait, à chaque liste nous pouvons faire correspondre un très grandnombre de sprites différents, c’est d’ailleurs par ce procédé-là que dans le numéro prochain nous représenterons une bonne centaine d’étoiles.
Ainsi, plus généralement, une sprite-List apparaît sur ce modèle :
Début liste :
dc. w hstart1-vstart1,vstop1 ; Premier sprite
dc. w données 1 de la ligne 1, données 2 de la ligne 1
dc. w hstart2-vstart2,vstop2 ; Deuxième sprite
dc. w données 1 de la ligne 1, données 2 de la ligne 1
dc. w hstartn-vstartn.vstopn ; nième sprite
dc. w données 1 de la ligne 1, données 2 de la ligne 1
i
dc. w 0,0 ; Fin de liste
Nous avons annoncé à l’Amiga les formes et emplacements de nos sprites, cependant, celui-ci ne « sait » pas spontanément quelle partie de la mémoire constitue une SpriteList. Effectivement, nous sommes dans l’obligation d’initialiser les sprites. Pour ce faire, nous avons à notre disposition 8 registres de 32 bits débutant en$ 120. Nous pokons respectivement dans leurs contenus les addresses de base des huit SpriteLists. Remarquez que les initialisations de ces registres doivent figurer dans la Copper-List pour la simple et bonne raison qu’ils sont utilisés par le hardware en tant que pointeur sur la donnée du sprite en cours de lecture. Ainsi, à chaque ligne de raster affichée, l’adresse contenue dans ces registres est incrémentée d’un mot. Conclusion, il faut la réinitialiser à chaque interruption Vertical Blank, tâche dont le Copper s’acquitte très bien.
Enfin, les 8 canaux de sprites doivent être initiali- sés à l’aide d’un MOVE.W + $ 8220,$ DFF096.
(A SUIVRE...)
Nous achèverons de parler des sprites dans le prochain numéro, et comme d’habitude, je me lève et je te bousule, comme d’habitude, tu ne te réveilles pas, comme d’habitude... Pardon : comme d’habitude, disais-je, nous illustrerons tout ceci par un programme d’animation d’étoiles qui, selon vous souhaits, pourra s’inscrire dans la Tube-lntro ou pourra être utilisé indépendamment.
The Little Zeus Brothers Compagny Limited Inc.
pixels
; Insérer ces 2 lignes dans la zone d'initialisation
des routines
jsr setco
jsr courbe

*
; Tube Intro de Little Zeus
; phase 2, dernière partie
; routine initialisant
l'ondulation
; dans la CopperList
courbe:
move.w culig.dO
; prend le numéro de la ligne
lea coco.aO
; pointe les data ondulations
lea colist,a1
; pointe copper list
move.l 31,d1
; ondulation sur 32 lignes
bb3:
move.w d0,(a0)+
move.w $ fffe,(a0)+
move.w $ 102,(a0)+
clr.b (a0)+
move.b (a1),(a0)+
; copie les valeurs ondulations
add.w $ 100,dO (
; prochaine ligne
add.w 1,a1
; prochaine ondulation
add.w 4,a0
; réserve place pour couleur
dbra d1,bb3
rts
; routine calculant à partir des données
; de l'ondulation du playfield avant
; celles du playfield arrière
setco: move.l 31,d3
lea colist,aO *
la:
move.b (aO),dO ; inverse les ondulations,
move.b 13,d1 ; aurait pu être fait a la main,
ourbe d ondulâtion du texte
move.b d0,d2 ; mais ainsi les tubes avant
asl.b 4,d2 ; et arrière sont symétriques,
sub.b d0,d1 add.b d1,d2 move.b d2,(a0)+ dbra d3,la rts
; on sélectionne le playfield avant ; pour ScrollRaster Pf 1 :
move.l b1,plane1 move.l b3,plane1+4 move.l b5,plane1+8 rts
AVANT
; on sélectionne le playfield arrière ; pour ScrollRaster Pf 2 :
move.l b2,plane1 move.l b4,plane1+4 move.l b6,plane1+8 rts
numéro de la ligne à laquelle commencera le scrolling vertical au moyen du copper.
4-
16
Il sera utilisé par les routines ayant accès à la copperlist. Culi g : dc.w $ 9e09
; ondulation de playfield arrière ; (forme une demi courbe)
; ces données seront modifiées par la routine setco colist:
dc. b 12,10,8,6,5,4,3,3,2,2,1,1,0,0,0,0
dc. b 0,0,0,0,1,1,2,2,3,3,4,5,6,8.10,12 even
drc2: dc.l 1 ; sens de rotation du PF arrière
dre: dc.l -1 ; sens de rotation du PF avant
num: dc.l 0
wt: dc.b 0 ; flag pour scrolling arrière
roi: dc.b 0 ; indicateur du mode rouleau
inc: dc.w 0 ; direction des rebonds
;===scrolling hori zontal===
; cette routine vérifie si les limites écran ; du scrolling horizontal des rebonds ; ne sont pas dépassées avant : move.w ml1,d0
cmp.w $ 9b09,d0 ; limite supérieure ?
Bne.s prd
move.w $ 100,inc ; oui -> sens opposé (+1 ligne)
bra.s pol prd:
cmp.w $ cb09,d0 ; idem pour la limite inférieure
bne.s prd2
move.w -$ 100,inc ; sens opposé (-1 ligne) pol:
cmp.b 0,rol ; mode rouleau ?
Beq prd2 ; si non on va en prd2
move.l drc.dO ; inverse les directions
cmp.b Sfb,d3
move.l drc2,drc ; des scrollings verticaux
beq stc2
move.l d0,drc2
cmp.b $ fa,d3
prd2:
beq sreb
move.w inc.dO
cmp.b $ f9,d3
add.w d0,ml3 ; remet à jour les waits dans la
beq upreb 1
add.w d0,ml1 ; CopperList car le scrolling
cmp.b Sf8,d3
add.w d0,ml2 ; a changé ligne.
Beq dwreb
add.w dO,culig
cmp.b $ f7,d3
rts
beq rolst
; on lance les différents scrolling---
cmp.b $ f6,d3
scrolIhor:
beq rolup
jsr ccol
cmp.b $ f5,d3
jsr scrup
beq roldw
jsr pfi ; sélectionne playfield avant
cmp.b $ 20,d3 bcc plusloin
move.l gfxbase,a6
lea rastport,a1
cmp.b 0,d3
move.l scspeed2,d0 ; valeur de décalage dans dO clr.l d1
beq.L stopsc
move.l 16,d2 ; début x
; si on est ici, c'est qu'on veut changer
move.l V)1,d3 ; début y
; la vitesse du scrolling
move.l 360,d4 ; fin x
clr.w d4
move.I 134,d5 ; fin y
chscc:
jsr scrolIraster(aô)
; calcul le nombre de fois à attendre
jsr pf2 ; sélectionne playfield arrière
; en fonction de la vitesse
lea rastport,a1
move.w d3,d4
move.l drc2,d1
move.w 40,d5
move.l scspeed2,d0
divu d4,d5
cmp.b 0,wt
move.l d4,scspeed2
beq ty clr.l dO
move.b d5,scspeed
add.l 1,char_adresse ; prochain caractère
ty:
bra.L avant “ ; et c'est reparti !
Clr.l d2 ; début x
rolst:
move.l 101,d3 ; début y
; rouleau arrêt
move.l 320,d4 ; fin x
clr.b roi ; donc rol=0
move.l 134,d5 ; fin y
bra stt ; puis saute en stt
jsr scrolIraster(aô)
rolup:
move.l scspeed2,d0 ; scrolling horizontal ? X
; rouleau départ haut
cmp.l 0,scspeed2 ; sinon on va en sspeed
move.w -$ 100,inc ; donc on enlève une ligne
bne.s sspeed ; on décrémente un compteur
move.b 1,rol ; donc mode rouleau activé
sub.l 1,scount ; si nul alors le scrolling
bra stt2 ; puis saute en stt2
bne.L jean ; repart, sinon il continue.
Roldw:
move.l 4,scspeed2 ; valeur du décalage
; idem pour départ vers le bas
move.b 10,scspeed ; nombre de fois à attendre
move.w $ 100,inc ; mais on ajoute une ligne
bra nxtcar ; saisit un nouveau caractère
move.b 1,rol
sspeed:
bra stt3 ; puis saute en stt3
sub.b $ 01,rows ; avons-nous scrollé assez pour
stc:
bne continuel ; afficher un nouveau caractère?
; scrolling arriéré desactive
move.b scspeed,rows
move.b 1,wt
move.l gfxbase,a6
bra rep
lea rastport,a1 move.l dlig,d0
stc2:
; scrolling playfield arrière activé
add.l 1,d0
move.b 0,wt
move.l 46,d1
bra rep
move.l 40,d2
stopsc:
nxtcar:
; arrêt sur place du scrolling pendant x fois
move.l char_adresse,aO
add.l 1,a0
move.b (a0),d3
move.b (a0),d0
; ici figurent les tests des options
mulu 2,d0
cmp.b $ ff,d3
move.l d0,scount
beq stt cmp.b $ fe,d3
clr.l scspeed2
add.l 2,char_adresse ; prochain caractère
beq stt2
bra.L avant
cmp.b $ fd,d3
stt:
beq stt3
; stoppe les scrollings verticaux
cmp.b $ fc,d3
clr.l dre
beq stc
clr.l drc2
rep:
add.l 1,char adresse ; pointe le prochain, caractère
bra.l nx.tcar
sreb:
; pas de rebonds
clr.w inc
; donc on ajoute 0 ligne
bra.s rep
upreb:
; rebond départ vers
le haut
move.w -$ 100,inc
; donc on enlèvera une ligne
bra.s rep
dwreb:
; rebond départ vers
le bas
move.w $ 100,inc
; donc on ajoutera une ligne
bra.s rep
stt2:
; rotation 1 (playfield avant va vers le haut)
move.l 1,drc
move.l -1,drc2
bra.s rep
stt3:
; rotation 2 (playfield avant va vers le bas)
move.l -1,drc
move.l 1,drc2
bra.s rep
plusloin:
; si on est ici c'est que l'on veut afficher
; un caractère donc appelle la routine idoine
bsr.s textl
add.1 $ 01,char_adresse
cmp.l finmessage,char adresse ; teste si on arrive
bne.s continuel
; à la fin du message
move.l message,char adresse ; on retourne au début
continuel :
rts
; affichage d'un caractère
textl:
liiùlu d0,d1
add.l 40,d1
cmp.b $ 20,d3
; est-ce un espace ?
Beq espace
; pas de caractère à afficher
lea let,a5
; pointe liste des lettres
clr.l d6
testl:
cmp.b (a5,d6),d3
; calcule sa position image
beq sort
add.l 1,d6
bra testl
sort:
move.b d6,d3
; calcul de l'adresse des datas graphiques
; du caractère
clr.w cl4
move.b d3,d4
; calcule la ligne du caractère
divu 8,d4
; en divisant son numéro par 8
move.w d4,d5
mulu 2560,d5
; multiplié par 2560
; (40*32*2=2560=largeur*hauteur*nbre de bitplane)
swap 64
; on récupéré le reste
mulu 5,d4
; multiplié par 5
add.l d4,d5
add.l picdata,d5
; plus l'adresse des graphiques
move.l d5,a0
; calcul de l'adresse de l'emplacement
; du caractère sur l'écran
move.l d1,d0
add.l b1,d0
move.l d0,a1
move.l d1fa2 x
add.l b3,a2 ; affichage du caractère move.l 31,d3 ; le caractère fait 32 lignes
caraboucle:
move.l 4,d2 ; copie 5 octets (40 pixels)
cb2:
move.b (a0),(a1)+ move.b 40(a0),(a2)+ add.w 1,aO dbra d2,cb2 add.w 75,a0 add.w 41,a1 add.w 41,a2 dbra d3,caraboucle espace: rts
rows: dc.b 1 scspeed: dc.b 10 char_adresse: dc.l message scount: dc.l 0 scspeed2: dc.l 4 message:
dc. b $ F7," TUBE ",$ F8,$ FE,0,64,$ FA,$ FF
dc. b " UNE NOUVELLE MEGA INTRO ",$ F5,0,$ 48,$ F7
dc. b "P0URI,,$ FF,$ F8," VOUS LECTEURS ",$ FE,0,16
dc. b $ FF,$ FC," LTZ ",$ F5,$ FB,$ FD,0,128+64
dc. b $ FF,$ FA,$ FC," ",$ FB,SFD,0
dc. b 48,$ F7," WELCOME! I ! !",$ F8,$ FE,0,64,$ FA,$ FF
dc. b " CECI EST UNE INTRO DE "
dc. b $ FF,$ F8," LITTLE ",$ FE,0,16,$ FF,$ FC
dc. b " ZEUS ",$ F5,$ FB,$ FD,0,128,$ FF
dc. b " POUR LES LECTREURS DE COMMODORE REVUE ",$ F7
dc. b $ FE, » THAT IS COOL YOU CAN WRITE WHAT "
dc. b "EVER YOU WANT ! ! !"
Dc.b 4," "
FINMESSAGE:
; Codes de contrôle :
; 1,2,4,5,8,20 : vitesses ; $ FF : PAS DE ROTATIONS ; SFE : ROTATION VERS LE HAUT ; $ FD : ROTATION VERS LE BAS ; SFC : STOP SCROLLING ARRIERE ; $ FB : REACTIVE SCROLLING ARRIERE ; $ FA : STOP AUX REBONDS ; SF9 : REBONDS DEPART VERS LE HAUT ; $ F7 : ARRETE LE ROULEMENT ; $ F8 : REBONDS DEPART VERS LE BAS ; $ F6 : ROULEAU VERS LE HAUT ; $ F5 : ROULEAU VERS LE BAS let: dc.b "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
dc. b ".?19012345678" even
ccolor: dc.l chcol
dc. w $ f06 ; liste des couleurs du scrolling chcol:
dc. w $ F00,$ F00,$ F00,$ F00,$ 000
dc. w $ D00,$ D00,$ D00,$ D00,$ 000
dc. w SB00,SB00,SBOO,$ B00,$ 000
dc. w $ 900,$ 900,$ 900,$ 900,$ 000
dc. w $ 700,$ 700,$ 700,$ 700,$ 000
dc. w $ 500,$ 500,$ 500,$ 500,$ 000
dc. w $ 400,$ 400,$ 400,$ 400
dc. w $ 000,$ 500,$ 500,$ 500,$ 500
dc. w $ 000,$ 700,$ 700,$ 700,$ 700
dc. w $ 000,$ 900,$ 900,$ 900,$ 900
dc. w $ 000,$ B00,$ B00,$ B00,$ B00
dc. w $ 000,$ 000,$ 000,$ 000,$ 000
dc. w $ 000,$ F00,$ F00,$ F00,$ F00 chcolf:
cnbl: de.I 108
anbl: dc.l 108
mocu: dc.l sinus
meu: dc.l rainbow
; liste des couleurs du logo
rainbow:
dc. w $ F00,$ F10,$ F20,$ F30,$ F40,$ F50,$ F60,$ F70,$ F80
dc. w $ F90,$ FA0,$ FB0,$ FC0,$ FD0,$ FE0,$ FF0,$ EF0,$ DF0
dc. w $ CFO,$ BFO,$ AFO,$ 9FO,$ 8FO,$ 7FO,$ 6FO,$ 5FO,$ 4FO
dc. w $ 3F0,$ 2F0,$ 1F0,$ 0F0,$ 0F1,$ 0F2,$ 0F3,$ 0F4,$ 0F5
dc. w $ OF6,$ OF7,$ OF8,$ OF9,$ OFA,$ OFB,$ OFC,$ OFD,$ OFE
dc. w $ 0 F F,$ 0E F,$ 00 F,$ 0C F,$ 0B F,$ 0AF,$ 09F,$ 08F,$ 07F
de.w $ 06F,$ 05 F,$ 04 F,$ 03 F,$ 02 F,$ 01F,$ 00 F,$ 00E,$ 000 de.w $ 00C,$ 00B,$ 00A,$ 009,$ 008,$ 007,$ 006,$ 005,$ 004
dc. w $ 003,$ 002,$ 001,$ 000,$ 100,$ 200,$ 300,$ 400,$ 500 de.w $ 600,$ 700,$ 800,$ 900,$ A00,$ B00,$ C00,$ 000,$ E00 rainbowf:
; valeurs de décalage des Playfields ; afin de créer l'effet de courbure du tube sinus:
de.w $ 77,$ 66,$ 66,$ 55,$ 55,$ 44,$ 44,$ 33,$ 33,$ 22,$ 22
dc. w $ 11,$ 11,$ 11,$ 00,$ 00,$ 00,$ 00,$ 00,$ 11,$ 11,$ 11
dc. w $ 22,$ 22,$ 33,$ 33,$ 44,$ 44,$ 55,$ 55,$ 66,$ 66,$ 77
dc. w $ 88,$ 88,$ 99,$ 99,$ AA,$ AA,$ BB,$ BB,$ CC,$ CC,$ 0D
dc. w $ DD,$ DD,$ EE,$ EE,$ EE,$ EE,$ EE,$ 00,$ 0D,$ 0D,$ CC
dc. w $ CC,$ BB,$ BB,$ AA,$ AA,$ 99,$ 99,$ 88,$ 88 sinusf:
; mettre ici les données de vos graphiques ; (alphabet, logo...)
LES RESCUES DE LITTLE ZEUS
Apartir de dorénavant et jusqu’à bientôt, vous ne pourrez plus vous passer des listings et autres astuces offerts dans cette rubrique. Car en plus de vous sortir de situations les plus difficiles, ils vous initieront à l’utilisation de certaines parties du hardware encore inexplorées.
Que je vous explique un peu comment ça va se passer : chaque mois, nous publierons une routine (en assembleur, ça bas de soie) qui vous permettra de prendre quelques fantaisies avec les jeux les plus récents possible, à condition bien sûr qu’ils soient d’une qualité suffisamment bonne. C’est déjà pas facile comme ça, s’il fallait en plus que je passe mon temps sur des navets, on l’appelerait mon oncle (NDLR : encore une comme ça et c’est la porte).
Seulement voilà, vous aurez remarqué que la place qui nous est impartie est limitée ; c’est pourquoi, dans le seul but de pouvoir en présenter encore plus, les explications seront données dans la rubrique Application, avec la Tube Intro (tiens, puisqu’on en parle, de la Tube Intro, j’en profite pour vous dire qu’elle sera bientôt disponible en téléchargement sur le 3615 Com- Rev. Un peu de pub n’a jamais fait de mal à personne).
On commence cool par deux jeux d’aventures, mais à partir du mois prochain vous trouverez ici l’équivalent des « Atatrucs » de nos confrères de Génération
4. .. en beaucoup plus étoffé, hé, hé, hé (NDLR : Non, Godeffroy, pas le fusil à pompe... Non... Arghhh !&.
Le principe est simple : on répertorie les emplacements sur la disquette où sont stockés les paramètres importants du jeu (nombre de vies, tableau de départ, etc.) et vous allez les modifier à votre guise. Plus facile que ça, tu meurs.
Bienvenue aux paumés et aux coincés. Dans les jeux, s’entend. Little Zeus est là pour vous aider à vous en sortir...
Une dernière précision : nous ferons un usage intensif de deux utilitaires indispensables, j’ai nommé l’assembleur K-Seka et l’éditeur de secteurs Smart- Disk. Ce sont mes préférés, mais bien sûr, rien ne vous empêche d’en utiliser d’autres. Après tout, tous les goûts ne sont-ils pas dans la nature ?
BATTLE TECH
Bien qu’assez facile à finir pour les bons aventuriers, ce jeu nécessite quelque aide. Après avoir sauvegardé votre partie, chargez SmartDisk et sélectionnez l’éditeur de directory, puis entrez dans le répertoire BATTLETECH pour pouvoir utiliser la fonction « fol- low » sur l’un des fichiers GAME. Un conseil : avant que d’entreprendre toute modification, notez bien le contenu original des deux premiers blocs, juste comme ça, au cas où... On n’est jamais trop prudent.
Vos personnages sont peu résistants et meurent à la moindre attaque de l’ennemi ? Pas de problème, voila de quoi les fortifier : éditez le premier bloc grâce à la fonction « sector edit » et écrivez autant de fois que vous possédez de personnages la séquence suivante :$ 0C$ 0C$ 0C$ 04$ 04$ 04$ 04$ 04$ 04$ 04, à partir des octets$ 1 A,$ 2C,$ 3E,$ 50 et$ 62 (1 fois à partir de chaque octet bien entendu). Et paf, c’est magique (NDLR : non, non, Décathlon), vos personnages sont excellents dans tous les domaines.
Si vous possédez quelques Mechs, vous avez certainement remarqué qu’eux non plus ne sont pas très résistants. Voici donc de quoi rendre les 2 premiers Mechs plus forts :
1" MECH
en$ 14b : répéter 19 fois l’octet$ 0b sur le premier bloc ; en$ 16c : 6 fois le mot$ 3311 puis$ 222211222222 sur le premier bloc ;
en$ 18e : 20 fois l'octet$ 0b sur le premier block.
2e MECH
$ 1c7 : même chose que pour$ 14b toujours sur le premier bloc ;
$ 1e9 : même chose que pour$ 16c sur le premier bloc ; $ 022 : même chose que pour$ 18 mais sur le second bloc.
Si ça se trouve, vous êtes déjà arrivé à la cache i secrète, et ça vous fait franchement ch... suer de chercher les codes qui ouvrent les portes. Placez vous donc sur le bloc 178 et remplacez en$ 90 le$ 66 ? ? Par$ 601a : dorénavant, le programme ne vérifiera plus si vous possédez les bons « yellow, red et blue codes » ; il ne vous manque plus que le « white code », alors allez sur le bloc 180, puis changez à partir de$ 176 le$ 6722 en un$ 6022.
Ah, pendant que j’y pense : après avoir entrepris toutes ces modifications, il ne faut pas oublier de recalculer les checksums des block. SmartDisk vous proposera de le faire tout seul comme un grand ; acceptez.
COSMIC PIRATE
Au bout d'un certain temps, le jeu devient trop répétitif ; c’est pourquoi je vous propose un listing qui modifie la sauvegarde de la partie en cours. Il n’est malheureusement pas commenté, mais je vous promets d’en publier prochainement un autre plus intéressant et bien sûr plus détaillé. Pour l’utiliser, c’est tout bête : il faut charger le K-Seka, lui alouer 100 Ko de mémoire de travail, taper le programme, puis entrer dans le code source, au label « nop éro
de la partie à modifier (entre 0 et 4). Vous assemblez (avec « a » suivi de deux fois), vous insérez la disquette Cosmic Pirate sans la protection contre l’écriture dans le drive DF0 :, et exécutez le programme avec « jstart » (débarrassez-vous du requester qui apparaît en cliquant sur « Cancel »).
Si vous voulez vous amuser à modifier les caractéristiques définies en fin de programme, faites attention à ce que les valeurs suivants les « dc.l » soient inférieures à 1 milliard, sinon elle seront considérées comme négatives et ne seront pas prises en compte. Les 05 attribués au drive, shield et weapon correspondent au numéro de matériel ; plus il est grand plus la protection qu’il représente est grande (le maximum est 5). Le niveau du vaisseau est compris entre 0 et 2 inclus. On peut également sélectionner les missions en supprimant les points-virgules de commentaire, mais il faut d’abord les décoder, car elles sont sur un mot.
Voilà qui clôt notre premier numéro des Rescues
de Little Zeus. On se retrouve le mois prochain avec
entre autres Milenium 2.2, ainsi que quelques jeux
d’action. A bientôt.
Little Zeus
APPEL A TARTE (mouais, bof) : si vous êtes bloqué
dans un jeu, si vous n’arrivez pas à détruire tous les
Zorglubs qui veulent envahir votre planète, ou à déli
vrer la charmante princesse des griffes du méchant
sorcier, une seule adresse :
Commodore Revue
Les Rescues de Little Zeus
1 bis, rue de Paradis
75010 Paris
Toute demande d’aide sera la bienvenue, à condi
tion qu’elle porte sur jeu reconnu bon et apprécié de
tous (évitez les pendus et autres batailles navales).
Merci.
; Cosmic Pirate - Bidouille par Little Zeus
org $ 40000
load $ 40000
FindTask=-294
OpenLib=-408
CloseLib=-414
0penDev=-444
Close0ev=-450
AddPort=-354
RemPort=-360
DoIO=-456
no_pi rate=0 ;
N* de la partie
start:
move.l $ 4,a6
sub.l a1,a1
jsr FindTask(a6)
move.l d0,reply+$ 10
lea reply,a1
jsr AddPort(AÔ)
lea diskio,a1
clr.l dO
clr.l d1
lea name,a0
jsr 0pen0ev(A6) ;
ouvre le trackdisk.device
lea diskio,a1
move.l reply,14(a1)
move 2,28 A1)
commande n°2
bsr.s io ;
lecture du secteur
bsr.s mod ;
effectue les modifs
lea diskio,a1
move 3,28(A1) ;
commande n*3
bsr.s io ;
écriture du secteur
move 4,28(A1)
lea diskio,a1 ;
envoie le tampon sur disquette
jsr DoI0(A6)
lea diskio,a1
move 9,28(A1) ;
arrête le drive
move.l 0,36(A1)
Jsr DoI0(A6) lea reply,a1 jsr RemPort(A6) lea diskio.al
jsr Close0ev(A6) ; ferme le trackdisk.device rts
name:
dc. b ‘trackdisk.device1,0 even
io:
move.l sector,40(a1) move.l 512,36(a1) move.l 28*512,44(A1) jsr DoIO(a6) rts
mod:
lea sector,a1 move.w 100,dû mulu no_pi rate.dO add.w d0,a1 add.w 22,a1 move.l a1,a2 ; lea missions,aO ; il faut enlever les
; moveq 9,d1 ; pour modifier les missions.
; la:
; move.w (a0)+,(a2)+
; dbra d1,la add.w 20,a1 lea chgmt,a0 moveq 20,dO
ici:
move.w (a0)+,(a1)+
dbra d0,ici
rts
; ne pas modifier les données suivantes
; sans avoir lu les explications chgmt:
dc. w 26
type de mission mini autorisé
dc. b 2
classement du vaisseau.
Dc.b 5
drive du vaisseau
dc. b 5
shield du vaisseau
dc. b 5
weapon du vaisseau
dc. w 0
inutilise
dc. w 0
mission en cours
dc. l 99999999
expérience
dc. l 10000000
"hit accuracy"
dc. l 99999999
"necessary kills"
dc. l 0
"unnecessary kills"
dc. l 300
nbre de missions commencées
dc. l 300
nbre de missions réussies
dc. l 0
???
Dc.l 999999999
argent
missions:
dc. w $ cccc,$ bbbb,$ aaaa,$ 9999
dc. w $ 8888,$ 7777,$ 6666,$ 5555
dc. w $ 4444,$ 3333 ; exemples de missions
reply: blk.l 8,0
diskio: blk.l 22,0 sector: blk.b 512,0
ASSEMBLEUR 68000 N°12
Hop ! Déjà un an que nous nous retrouvons tous les mois pour découvrir les secrets internes de notre Amiga. L’occasion rêvée pour un petit bilan des connaissances déjà acquises (ah bon ?).
n avait commencé cette série par une étude du MC68000 lui-même, ses instructions, ses modes d’adressages, etc. Un travail fastidieux, certes, qui s’était étalé sur plusieurs numéros, mais ô combien indispensable.
Les choses avaient commencé à devenir plus intéressantes à partir du moment où nous nous étions occupé du système d’exploitation de rAmiga, et plus particulièrement de son interface graphique, j’ai nommé Madame Intuition. La première chose que nous avions vu était comment ouvrir un écran (Screen en anglais), puis une fenêtre (Window), suivie d’un menu (heu... Menu), pour en arriver aux gadgets (je vous le donne en mille : Gadgets), au terme desquels la programmation d’un logiciel sous Intuition n’aura pour ainsi dire plus aucun secret pour nous. Alors un peu de patience et de courage, on commence à en voir le bout...
L’INSPECTEUR GADGET (SUITE)
Mais reprenons plutôt notre étude de la structure Gadget là où nous l’avions laissée, c’est-à-dire juste après les « Activation Flags » (suivez sur le tableau du mois dernier).
On trouve à leur suite un mot qui détermine le type du gadget :
Gadget Type Valeur Signification
1 BOOLGADGET gadget booléen
3 PROPGADGET gadget proportionnel
4 STRGADGET gadget de chaîne ou numérique
$ 10 SIZING gadget de modification de taille de
fenêtre
$ 20 WDRAGGING gadget de déplacement de fenêtre
$ 30 SDRAGGING gadget de déplacement d’écran
$ 40 WUPFRONT gadget de « dépilement » de fenêtre
$ 50 SUPFRONT gadget de « dépilement » d’écran
$ 60 WDOWNBACK gadget « d’empilement » de fenêtre
$ 70 SDOWNBACK gadget «d’empilement» d’écran
$ 80 WCLOSE gadget de fermeture de fenêtre $ 1000 REQGADGET gadget Requester $ 2000 GZZGADGET gadget bord dans une fenêtre GIMMEZEROZERO $ 4000 SCRGADGET gadget d’écran $ 8000 SYSGADGET gadget système
On n’utilisera en général que l’un des trois premiers types possibles (BOOL, PROP ou STR). Sachez toutefois que l’expression « gadget système » regroupe tous les gadgets « standards » de fenêtre et d’écran listés dans ce tableau.
Viennent ensuite dans la structure plusieurs pointeurs.
Le premier désigne l’adresse d’une structure Image, au cas où votre gadget en contiendrait une (une Image n’est rien d’autre qu’un motif défini par vous, qu’intuition dessinera dans votre gadget. Voir plus loin dans cette même rubrique).
Le second désigne l’adresse d’une seconde structure Image, qui sera affichée à la place de la première lorsque le gadget sera sélectionné, ce qui permet des effets intéressants, comme par exemple un interrupteur ON OFF, etc. Ceci n’est bien sûr valable que si le bit GADHIMAGE est mis dans les Gadgets Flags (cf. Mois dernier).
Le troisième pointeur désigne l’adresse d’une structure IntuiText, au cas où nous voudrions afficher un texte quelconque dans notre gadget (pour le détail d’une structure IntuiText, voir Commodore Revue numéro 13, même rubrique).
On trouve ensuite un mot long nommé « Exclude » qui indique si l’activation de notre gadget doit provoquer la désactivation d’autres gadgets présents. On assure de source normalement bien informée, que cette fonction n’est pas d’une fiabilité exemplaire, qu’elle provoquerait un Guru de temps en temps... Voilà une affirmation que je n’ai pas encore eu la chance, si l’on peut appeler ça de la chance, de vérifier.
On continue la structure Gadget avec un pointeur sur une structure Speciallnfo, qui ne sera utilisée qu’avec les gadgets de chaîne, entiers et proportionnels. Nous y reviendrons en temps et en heure, c’est- à-dire dans quelques paragraphes.
Il ne nous reste plus qu’à donner un numéro d’identification (ID) à notre gadget, et la structure sera complète, le dernier mot long, « User Data », étant géré de manière interne par Intuition.
La structure Gadget telle que je viens de la décrire est valable pour un gadget de type booléen. Il faudra lui faire subir quelques modifications, heureusement mineures, pour un gadget de chaîne ou proportionnel.
TRAVAIL A LA CHAINE
Qu’est-ce donc qu’un gadget dit « de chaîne » ? L’exemple évitant toujours de longues et ennuyeuses explications, en voici un : la fonction « Rename » du Workbench utilise un gadget de chaîne pour recevoir le nouveau nom de l’objet concerné. Il s’agit en gros d’un moyen simple et élégant d’attendre une entrée au clavier de la part de l’utilisateur.
D’autant plus que de tels gadgets disposent de plusieurs facilités d’édition :
Flèches gauche droite : Déplacent le curseur d’un caractère respectivement vers la gauche ou la droite. Flèches gauche droite avec Shift : Déplacent le curseur respectivement en début et en fin de chaîne. Del : Efface le caractère situé sous le curseur. BackSpace : Efface le caractère situé à gauche du curseur.
Return : Met fin à l’édition du texte.
Amiga droite A : Fonction « Undo » (rétablit le texte initial).
Amiga droite X : Efface complètement le texte. Pour mettre en œuvre un gadget de chaîne, il suffit de définir une structure Gadget comme ci-dessus, en prenant soin d’initialiser le mot long Speciallnfo avec l’adresse d’une structure Stringlnfo (à ne pas confondre avec la structure IntuiText !&. Une telle structure Stringlnfo est définie comme suit :
Structure Stringlnfo Offset Signification 0 Text Buffer
4 Undo Buffer
8 Start Cursor
10 Maximum Length
12 First Char
14
16 Ces cinq mots sont
18 définis par Intuition
20 22
24 RastPort
28 Integer
32 Keymap
Examinons tout ça de plus près...
Le premier mot long pointe sur un buffer suffisamment grand pour recevoir le texte entré.
Le second mot long pointe sur un buffer « Undo », qui servira lors de l’appui sur les touches Amiqa droite A.
Le mot « Start Cursor » détermine la position du curseur dans la chaîne à l’ouverture du gadget ; il vaut mieux le fixer à 0 pour qu’il pointe sur le premier caractère !
Le mot « Maximum Length » détermine le nombre maximum de caractères que le texte pourra contenir.
« First Char » indique à partir de quel caractère du texte celui-ci doit être édité. Il vaut mieux également le mettre à 0, afin que ce soit à partir du premier caractère.
Les cinq mots suivants seront utilisés par Intuition durant l’édition du texte. On y trouvera à la sortie divers renseignements, tel le nombre de caractères effectivement entrés, etc.
« RastPort », maintenant familier, n’a pas à être ini- tialisé par nous ; pour une fois, Madame Intuition s’en chargera toute seule, comme une grande.
« Integer» contiendra, en fin d'édition, la valeur entrée dans un gadget de type entier.
Enfin, « Keymap » pointe sur une table de définition de clavier présente en mémoire, qui sera utilisée lors de l’édition du texte. Tout ceci à condition bien entendu que vous ayez fixé le bit « ALTKEYMAP » dans les Gadget Flags (encore une fois, cf. Mois dernier).
Les gadgets entiers ne sont, finalement, qu’une variante des gadgets de chaîne, qui ne permettent que l’édition de chiffres (0 à 9). La valeur entrée au clavier sera automatiquement convertie par Intuition en un mot long et placée au label « Integer ». C’est tout.
DE LA PROPORTION
C’est ici que les choses se compliquent un peu. Le booléen, ça va, les chaînes aussi, mais les gadgets proportionnels, c’est autre chose, ça, ma bonne dame. Je vous conseille donc de vous asseoir confortablement avant de continuer à lire (au besoin, prenez un verre et allumez un cigare).
Des gadgets proportionnels, vous en utilisez plus souvent que vous ne le croyez : les ascenseurs dans les fenêtres en sont, pour ne citer qu’eux. Il s’agit donc de gadgets qui donnent la possibilité de déplacer un curseur dans un cadre donné. Les tailles du curseur et du cadre sont bien entendu totalement définissables.
Pour programmer de tels gadgets, il nous faut évidemment une structure Gadget, identique à celle déjà vue. Le mot « Gadget Type » devra être fixé sur 3 (Pro- portional Gadget), le pointeur « Image » désignera la structure Image définissant le curseur, et le pointeur « Speciallnfo » désignera l’adresse d’une structure Pro- plnfo, structure que voici, sans plus attendre, détaillée pour vous :
Structure Proplnfo Offset Signification
0 PropFlags
2 Hpos
4 Vpos
6 HorizBody
8 VertBody
10 à 20 Six mots utilisés par Intuition Seuls les quatre premiers bits du mot « PropFlags » sont significatifs :
PropFlags
Bit Valeur Signification
0 1 AUTOKNOB
1 2 FREEHORIZ
2 4 FREEVERT
3 8 PROPBORDERLESS
Une fois n’est pas coutume, commençons par la fin : normalement, lorsqu’un gadget de type proportionnel est mis en oeuvre, Intuition encadre automatiquement le curseur (comme elle le fait pour un titre de menu, par exemple). Fixer le bit PROPBORDERLESS permet d’éviter cet encadrement.
FREEVERT et FREEHORIZ autorisent, s’ils sont fixés, le déplacement vertical et horizontal (respectivement) du curseur à l’intérieur de son cadre. Au moins l’un de ces deux bits doit être mis !
AUTOKNOB est d’un grand secours pour la mise au point de programmes, en attendant la version finale,
plus esthétique. Ce bit fait en sorte qu’intuition gère d’elle-même la forme et la taille du curseur, proportionnellement au cadre qui le contient. Très pratique.
Revenons à la structure Proplnfo. Hpos et Vpos contiennent les positions de départ du curseur, relativement aux bords du cadre qui le contient. Des valeurs comprises entre$ 0 (gauche haut) à $ FFFF (bas droite) sont autorisées.
HorizBody et VertBody déterminent le pas de déplacement du curseur dans son cadre. Prenons pour exemple un gadget permettant de régler l’intensité d’un son. Le programme autorise des valeurs entières comprises entre 0 et 63, soit 64 valeurs différentes possibles. Dans ce gadget, si Hpos (ou Vpos, ne soyons pas sectaires) est égal à 0, le curseur sera totalement à gauche dans son cadre (respectivement, en haut) ; si au contraire, Hpos vaut $ FFFF, le curseur sera totalement à droite dans son cadre (respectivement, en bas). Pour obtenir exactement 64 positions possibles pour le curseur, il faut spécifier pour HorizBody la valeur$ FFFF 64, soit$ 400 (1024 décimal). Compris ? Bon, plus généralement, les valeurs HorizBody et VertBody se calculent d’après la formule : $ FFFF Nombre de positions du curseur possibles Les 6 derniers mots de la structure Proplnfo sont gérés de manière interne par Intuition ; on y retrouve, à la fermeture du gadget, les nouvelles positions du curseur à l’intérieur de son cadre, entre autres.
Pour le cas où le bit AUTOKNOB serait fixé, et pour reprendre l’exemple ci-dessus, notre curseur ferait exactement 1 64ième de la taille totale du cadre ; dans le cas contraire, c’est à vous de faire en sorte, en le dessinant, qu’il soit à la bonne taille.
L’IMAGE A LA PAROLE
Si vous reprenez la structure Gadget, vous remarquerez un pointeur sur une structure Image, qui définit l’aspect de votre gadget. Une telle structure n’est vraiment pas longue à initialiser :
Structure Image
Offset
Signification
0
Xpos
2
Ypos
4
Largeur
6
Hauteur
8
Nombre de plans de bits
10
Image Data
14
PlanePick
15
PlaneOnOff
16
Image Data 2
Les quatre premiers mots ne posent aucun problème de compréhension. Faites seulement attention à ce que Xpos et Ypos soient exprimés relativement aux bords du gadget, de la fenêtre ou de l’écran père de l’Image (une Image peut en effet être dessinée dans une fenêtre ou un écran. Hein ? Vous ne me croyez pas ? Et les icônes du Workbench, c’est du poulet, peut-être ?).
Le cinquième mot définit, de la même manière que pour un écran, sa profondeur, c’est-à-dire le nombre de plans de bits qui composent l’Image, c’est-à-dire
(suite page 51) (suite de ta page 42)
enfin le nombre de couleurs. Il semble évident que ce nombre ne peut être supérieur à celui de l’écran père.
Suit alors un pointeur sur les données graphiques de l’image elle-même, définies plan de bits par plan de bits.
L'octet PlanePick est un peu plus délicat à saisir ; si vous avez déjà programmé des Bobs en AmigaBa- sic, cette notion devrait vous être familière. Dans le cas contraire, voici une succinte explication : il n’est pas obligatoire que l’Image s'affiche plan de bits par plan de bits à l’écran. On peut faire en sorte, par exemple, que le premier plan de bit de l’Image soit écrit dans le second plan de bits de l’écran, etc. Ceci permet de faire varier les couleurs d’une même Image, sans avoir à la redessiner entièrement. Dit de manière encore plus simple, PlanePick détermine les couleurs de l’Image.
PlaneOnOff est du même accabit : cet octet détermine ce qu’il adviendra des plans de bits non affectés par l’affichage de l’Image ; si vous désirez que ceux-ci restent tels quels, indiquez zéro, et s’ils doivent être inversés, indiquez un.
Et on termine cette structure Image par un pointeur sur d'éventuelles données graphiques supplémentaires.
Un petit mot pour en terminer avec les Images : comme je crois l’avoir fait remarquer plus haut, une Image peut-être dessinée n’importe où, que ce soit dans une fenêtre, un écran, ou un Requester. Il existe une fonction Intuition, Drawlmage (offset 114) qui attend quatre paramètres : dans aO, l’adresse du Rast- Port dans lequel l’Image doit être dessinée, dans a1, l’adresse de la structure Image concernée, dans dO et d1 les positions X et Y, encore une fois relatives aux bords du RastPort en question.
Il ne nous reste finalement plus qu’une certaine composante particulière à étudier, j’ai nommé les Borders.
BORDER
Kesako, « Border » ? Si je vous dis qu’en français bien de chez nous, « Border » signifie « bord », vous ne serez guère plus avancés.
Simplement, il s’agit d'un élément d’intuition qui permet de dessiner des cadres d’un nombre quelconque de côtés. Un exemple aussi bête qu’idiot est une fenêtre : ce n’est plus ni moins d’un Border à quatre côtés !
L’avantage de pouvoir utiliser les Borders directement dans nos Requesters est évident : l’esthétique. Bien sûr, cela demande de s’em... s’enquiquiner un peu plus lors de la programmation, mais le résultat est tout de même beaucoup plus beau.
Voyons d’abord le cas de plus simple. Nous voulons dessiner un Border, comme ça, â l'écran, par caprice ou par nécessité. Madame Intuition met une fois de plus une de ses fonctions à notre disposition, j’ai nommé DrawBorder. D’offset 108, elle attend quatre paramètres : dans aO, l’adresse du RastPort dans lequel dessiner le Border, dans a1, l’adresse de la structure Border concernée, dans dO et d1, les coordonnées X et Y du premier point du Border. C’est tout.
Structure Border ? J'ai dit « structure Border », moi ? Tiens donc...
Structure Border
Offset Signification 0 Xoffset
2 Yoffset
4 Détail Pen
5 Block Pen (inutilisé)
6 Draw Mode
7 Nombre de points
8 Coordonnées
12 Next Border
Et c’est reparti mon kiki.
Xoffset et Yoffset indiquent les coordonnées du premier point, relativement à celles données lors de l’appel de la fonction. Ça peut sembler ridicule et superflu, comme ça, mais lorsque le Border est intégré à un Requester, Xoffset et Yoffset indiquent les coordonn- nées du premier point relativement au bord du Requester.
DetailPen et BlockPen sont désormais familiers, je ne m’étendrai donc pas dessus. Sachez seulement que BlockPen est ici inutilisé, allez savoir pourquoi (moi je sais, mais faites donc un effort intellectuel, que diable !
DrawMode n’est pas lui non plus un inconnu, il détermine le mode de dessin (JAM1, JAM2, etc.).
Le mot suivant indique le nombre de points dans le cadre ; n’oubliez jamais qu’il faut trois points pour dessiner deux droites ayant un sommet commun.
Le mot long suivant pointe suf la table des coordonnées de chacun des points d cadre, un par un, à la suite l’un de l’autre.
Et finalement, suit un pointeur t ur une éventuelle structure Border supplémentaire. C omme d’habitude, un zéro indique qu’il n’y a pas d’autre structure.
ET DE QUATRE !
Quatre quoi ? Mais voyons, quatre pages bien remplies, c’est déjà pas si mal. Du coup, je vous donne rendez-vous au mois prochain où nous verrons comment intégrer une Image et un Border dans un Requester, faisant lui-même partie d’une fenêtre, elle-même assujettie à un écran. M’excuserez si j’omets le menu.
Max
Cette nouvelle rubrique vient s’ajouter à « AmigaDos Minimum » ; il s’agit d’un complément qui nécessite les connaissances de base présentes dans cette dernière. En fait, le but sera de fournir des informations supplémentaires, d’approfondir et d’exploiter la richesse de certaines commandes de l’AmigaDos.
Rentrons dès maintenant dans le vif du sujet, avec pour débuter la commande List, car elle est très riche, mais aussi très utile (comme en Basic...). Entrée seule, List informe plus abondamment que DIR :
System Dir rwed 13-Aug-88 18 :16 :10
: Message écrit dans le gadget Comment de Info
System.info 894 rwed 13-Aug-88 18 :12 :06
Shell empty rwed 13-Aug-88 18 :08 :18
Etudions les informations fournies, colonne par colonne. La première colonne contient le nom du fichier ; la deuxième indique sa taille, ou « Dir » lorsqu’il s’agit d’un répertoire ; dans la troisième est codé le Protection Status (état de protection) des fichiers, de la manière suivante : r (Read) autorise la lecture w (Write) autorise l’écriture e (Exécuté) autorise l’exécution d (Delete) autorise l’effacement
Enfin les éventuels commentaires (inscrits dans le menu Info du Workbench) sont affichés, précédés du signe » : ».
Cependant il faut savoir qu’AmigaDos gère un autre code, « a », qui signifie « Archive » et indique si le fichier a été modifié ou non.
Il faut aussi remarquer que ces mêmes codes sont utilisés par la commande Protect. Il est ainsi possible de protéger un fichier contre l’effacement, en écrivant par exemple :
Protect Bonjour rwe Le fichier Bonjour est maintenant protégé en écriture. AmigaDos 1.3 apporte à Protect et à List la possibilité de gérer de nouveaux codes : h (Hidden) Fichier n’apparaissant pas au catalogue s (Script) Fichier édité sous Ed et démarrant avec Exécuté
p (Pure) S’utilise avec Résident a (Archive) Voir plus haut Attention, protéger un répertoire ne protégera pas son contenu d’un « Delete... ALL ».
Dans la quatrième colonne, se trouvent la date et l’heure de création ou de dernière modification du fichier. A ce sujet, l’option DATES de List permet d’afficher toutes les dates au format JJ-MMM-AA au lieu des jours de la semaine, en anglais qui plus est. A l’inverse, l’option NODATES supprime leur affichage.
Le traitement des dates par List ne s’arrête pas là : grâce à l’option SINCE, il est possible de n’afficher que les fichiers créés ou modifiés depuis la date spécifiée. Dans le même style, UPTO n’affiche que les fichiers créés ou modifiés avant la date. Dans ces deux options, il est possible d’utiliser les deux formats de date, JJ-MMM-AA ou encore “Saturday’ ou “Yester- day’ quand il s’agit de la semaine courante.
Passons maintenant aux autres options :
S Chaîne : seuls les noms de fichiers contenant la chaîne citée seront affichés. Si la chaîne contient des espaces, il faudra utiliser les guillemets ;
P ou PAT : permet d’utiliser les jokers (voir « AmigaDos Minimum » du numéro 14) ;
TO NomDeFichier : détourne la sortie vers ce fichier enregistré en ASCII ;
KEYS : très importante en cas d’utilisation d’un éditeur de secteurs, puisqu’elle permet d’afficher l’adresse du premier bloc de l’enregistrement ;
FILES : une option ajoutée par le 1.3 qui permet de ne lister que les fichiers ;
DIRS : liste seulement les répertoires ;
NOHEAD : supprime la première ligne du listing (listage pour les anglophobes...) ;
QUICK : n’affiche que les noms de fichier.
Voilà, c’est terminé en ce qui concerne les options de List, il faut désormais acquérir l’habitude de les utiliser.
Passons maintenant à une commande présente dans le répertoire C :. Autrefois un programme du Domaine Public, More permet d’afficher, à des fins de lecture, des fichiers ASCII. Il possède des commandes très intéressantes de recherche et de déplacement dans le texte :
Espace : saut à la page suivante
Return : saut à la ligne suivante
q ou »C : quitte More
H : HELP (aide), liste les commandes, en
anglais...
mot : permet de rechercher un mot dans le
fichier
n : poursuit la recherche
»L : efface la page d’écran
: saut à la première page
: saut à la dernière page
%N : avance N % dans le fichier
BackSpace : saut à la page précédente
E : gère l’unité logique ENV :
(Note : le caractère » dénote la touche Ctrl)
C’est déjà le moment de vous quitter, rendez-vous au prochain numéro.
Phantasia
Chose promise, chose due : le quatrième volet de notre initiation à l’Amiga-Basic va nous emmener loin, très loin, au royaume des boucles et des sauts...
INITIATION A LAMIGA-BASIC
Une petite précision s’impose d’emblée : par « boucle », on entend la répétition d’un nombre quelconque d’instructions (plus généralement, de lignes de programme) pendant un certain nombre, pré-défini ou non, de fois. Par « branchement » ou « saut », on entend le fait de « sauter », à l’aide d’instructions appropriées, plusieurs lignes du programme, avec éventuellement retour à la case départ (sans toucher 200000).
Ces deux notions pourraient à priori sembler parfaitement distinctes. Elles le sont.
Si on les rapproche ainsi, c’est uniquement parce qu’elles sont souvent utilisées en parallèle, bien que ce ne soit absolument pas obligatoire (heureusement, d’ailleurs). Cela dit, les sauts sont souvent nécessaires, suite à différents tests (voir le mois dernier pour plus de précisions sur les tests), et on n’en fait pas tout un fromage pour autant. Que voulez-vous, ce n’est pas moi qui ai inventé le Basic, faut faire avec ce qu’on
a. L’usage veut que l’on rapproche les boucles des sauts et réciproquement, rapprochons donc.
BOUCLE-LA UN PEU !
Il convient maintenant de distinguer deux types de boucles. Dans le premier, le programmeur sait à l’avance combien d’itérations sa boucle devra effectuer. Dans le second, il n’en sait rien du tout !
Prenons comme exemple un programme devant afficher tous les nombres entiers compris entre 1 et 1000. En tant que rédacteur du programme, vous savez à l’avance qu’il va vous falloir effectuer 1000 itérations sur l’instruction PRINT, soit une pour chaque nombre à afficher (à moins que vous ne préfériez taper 1000 fois dans votre listing l’instruction PRINT ?).
Voici un programme qui fait ça très bien :
FOR i = 1 TO 1000 PRINT i NEXT i
Le « traduire » en français donnerait à peu près ceci :
pour i compris entre 1 et 1000 afficher i prochain i
(les puristes de l’algorythmie et du pseudo-code vont certainement me haïr s’ils lisent ceci...).
L’instruction FOR permet d’utiliser une variable, ici « i », en tant que compteur de boucle. Au début de la boucle, cette variable prend la valeur de départ indiquée juste après le signe « = », ici 1. Basic exécute ensuite toutes les instructions comprises entre le FOR et le NEXT. Quand il rencontre ce dernier, le compteur de boucle est incrémenté (augmenté), les instructions entre FOR et NEXT à nouveau exécutées, etc., jusqu’à ce que le compteur atteigne la valeur de fin de boucle spécifiée après leTO, ici 1000. C’est on ne peut plus simple.
Une variante de l’instruction FOR consiste à donner un pas à la boucle :
FOR i = 1 TO 1000 STEP2 PRINT i NEXT i
Les plus attentifs auront remarqué qu’on a ajouté, à la suite de la valeur de fin de boucle, l’instruction STEP, qui signifie littéralement « pas ». Si vous exécutez ce programme, seuls les nombres entiers impairs compris entre 1 et 1000 s’afficheront à l’écran. Le STEP définit donc l’incrément du compteur de boucle (dans notre exemple, le compteur « i » est incrémenté de 2 à chaque itération de la boucle). Un STEP négatif est également possible :
FOR i = 1000 TO 1 STEP 1 PRINT i NEXT i
Ainsi qu’un STEP réel :
FOR i = 1 TO 1000 STEP 0.1 PRINT i NEXT i
Lorsque je dis que « le nombre d’itérations est connu à l’avance », c’est à la fois vrai et faux. Continuons notre exemple des nombres entiers à afficher, mais modifions-le de telle sorte que l’utilisateur puisse entrer le premier nombre à partir duquel il souhaite voir la liste s’afficher :
INPUT « Entrez le premier nombre » .Premier FOR I = Premier TO 1000 PRINT i NEXT i
Faisons même encore plus fort : l’utilisateur pourra définir lui-même les bornes de la boucle :
INPUT « Entrez le premier nombre » ;Premier INPUT « Entrez le dernier nombre » ;Dernier FOR i = Premier TO Dernier PRINT i NEXT i
En fait, ici, nous ne connaissons ni la valeur de départ de la boucle, ni sa valeur de fin. Il est pourtant possible d’utiliser l’instruction FOR... à condition toutefois que «Premier» soit effectivement inférieur à « Dernier » ! Dans le cas contraire, il ne se passerait rien du tout ! Cela dit, un simple test (que je vous laisse le soin d'écrire) permet de régler ce problème. Second type de boucle, celles dont on ne connaît à priori pas le nombre d’itérations. Un exemple classique est lorsque l’on demande d’entrer un nombre compris entre deux valeurs précises : on ne sait à priori pas combien de fois l’utilisateur va donner une réponse fausse avant de donner la bonne ! On utilise pour ce type de boucle l’instruction WHILE... WEND :
Nombre = 0
WHILE Nombred OR Nombre>100
INPUT « Entrez un nombre entre 1 et 100 » ;Nombre
WEND
PRINT « Merci. »
(ce programme est une alternative intéressante à celui proposé le mois dernier). Essayons de « traduire » ce programme en français :
Nombre = 0
tant que Nombred OU Nombre>100 demander Nombre fin de boucle TANT QUE
Première constatation, la valeur de la variable Nombre doit être connue à l’avance, afin de pouvoir la tester dans la boucle WHILE. C’est l’objet de la déclaration « Nombre = 0 ». Seconde constatation, ce test de la variable « Nombre » est effectué AVANT l’instruction INPUT, alors que dans une boucle FOR, le test de la valeur de fin de boucle est effectué lorsque Basic rencontre l’instruction NEXT, c’est-à-dire APRES que le bloc d’instructions entre FOR et NEXT ait été exécuté. Cette seconde constatation en amène une troisième : si, dans notre déclaration de la variable « Nombre », nous lui avions assigné une valeur comprise entre 1 et 100, le programme n’aurait même pas demandé d’entrer un nombre ! Essayez, vous verrez bien.
A titre d’exercice, regardez bien le test que nous effectuons après l’instruction WHILE, et essayez de comprendre pourquoi nous avons utilisé OR plutôt que AND (au besoin, servez-vous du tableau publié le mois dernier...).
Pour résumer, nous pouvons dire que cette boucle exécute toutes les instructions comprises entre le WHILE et le WEND, et ce tant que la condition exprimée est vraie (petit truc mémotechnique : WHILE en
anglais signifie « tant que », et WEND est la contraction de WHILE END, soit littéralement « fin de WHILE »).
C’est tout bien compris ? Chouette, nous pouvons donc passer aux sauts et branchements.
LE SAUT TERNE
Rapidement, nous allons voir le saut le plus simple qui soit en Basic, l’instruction GOTO, qui signifie littéralement « aller à » (jacta est ?).
Cette instruction permet de détourner le déroulement normal du programme. Jusqu’ici, nous n’avons vu que des programmes se déroulant linéairement, c’est-à-dire ligne par ligne, tel qu’il a été écrit. L’instruction GOTO permet de sauter directement tout un bloc de lignes, aussi bien en avant qu’en arrière.
Prenons encore un exemple, un de plus. Imaginons un menu donnant le choix entre cinq options différentes (lorsque je dis « menu », je n’entends pas, mais alors là pas du tout, un menu déroulant dans le plus pur style Amiga, avec souris et tout et tout) : Menu :
PRINT « 1 > Première option«
PRINT « 2 > Seconde option«
PRINT « 3 > Troisième option«
PRINT « 4 > Quatrième option«
PRINT « 5 > Cinquième option«
PRINT
INPUT « Votre choix » ;Choix
IF Choix = 1 THEN GOTO Optionl IF Choix = 2 THEN GOTO Option2 IF Choix = 3 THEN GOTO Option3 IF Choix = 4 THEN GOTO Option4 IF Choix = 5 THEN GOTO Option5 GOTO Menu Optionl :
’ Ici, on fait plein de choses
’ Et on retourne au menu GOTO Menu
’ Suite du programme ici ’ avec les autres options
Bon, d’accord, ce programme n’est pas un modèle du genre, mais il illustre très bien notre propos. Vous l’avez compris ? Non ? Alors je vous laisse un mois pour y réfléchir... A bientôt !
Michel Descoins
LE GUIDE DE L'AMIGA
Logiciels d'application et périphériques
Édité p. COMMODORE REVUE
256 PAGES D'informations sur L'amiga 48 Francs
LART DU LANGAGE-MACHINE
Il est bien connu que pour réaliser des routines requiè- rant une grande vitesse d’exécution, rien ne vaut l’assembleur. En fait, il serait plus juste de dire que quelque soit le langage utilisé, l’important est de bien l’utiliser.
Un programmeur en langage-machine averti, peut très rapidement distinguer trois types de programmes:
1) les très bien écrits;
2) les bien écrits;
3) les inqualifiables!
Il n’y a pas de règles absolues qui permettent de distinguer ces trois types de programmation, seulement des “lignes de conduite”. Bien qu’elles tendent à varier d’un programmeur à un autre, si le code est bon ou excellent, personne ne viendra dire le contraire. I_e but de cet article est de vous aider à écrire des programmes que l’on appréciera à leur juste valeur.
De l’excellent code se reconnaît très facilement; il a tendance à utiliser presque tous les trucs connus, voire même à en inventer de nouveaux. Sa qualité essentielle est... de faire ce pour quoi on l’a écrit!
Du bon code est plus facile à comprendre pour le débutant suivant pour ainsi dire à la lettre les règles connues de la programmation en assembleur. Il n’est malheureusement pas toujours optimisé, mais présente l’avantage de fonctionner.
Reste le code “inqualifiable”, qui est... heu... disons pas très joli à voir.
La marche à suivre pour obtenir un code opitmal peut-être divisée en trois étapes;
1) Optimisation “ligne à ligne”;
2) Optimisation locale (sous-programmes, etc.);
3) Optimisation globale.
En fait, ces trois étapes peuvent paraître à première vue identiques. Il est vrai qu’elles ne diffèrent que très peu.
L’OPTIMISATION “LIGNE A LIGNE”
Le jeu d’instruction du MC68000 n’est peut-être pas très vaste, mais ses nombreuses modes d'adressages autorisent une programmation plus qu’optimisée, aussi bien en temps d’exécution qu’en taille de programme (par la suite, nous ne nous référons plus qu’au 68000 en oubliant les 68020 et 68030, car c’est à l’heure actuelle le processeur le plus répandu). Les premières règles à observer lors du choix des instructions sont:
Eviter les valeurs immédiates sur 32 bits;
Eviter les valeurs 32 bits avec les registres d’adresse; Eviter l’adressage absolu en mode 32 bits;
Eviter les instructions MUL et DIV;
Utiliser si possible la forme QUICK des instructions; Oublier que l’instruction CLR existe!
Illustrons un peu ces règles; vous trouverez ci- dessous, numérotés de A à E, quelques exemples
simples d’optimisation.
A:
move.1
* 1,d0
6 octets
12 cycles
B:
add.1
* 2,a0
6 octets
16 cycles
C:
move.1
* 3,Var
10 octets
28 cylces
D:
muls.w
* 10,dO
4 octets
70 cycles
E:
clr.1
dO
2 octets
6 cycles
Ces quelques lignes seraient plus efficaces écrites
comme suit;
A:
moveq
* 1,d0
2 octets
4 cycles
B:
addq.w
* 2,a0
2 octets
8 cycles
C1 :
moveq
* 3,d0
2 octets
4 cycles
move.1
d0,Var
2 octets
20 cycles
Total :
8 octets
24 cycles
C2:
moveq
* 3,d0
2 octets
4 cycles
move.1
d0,Var (a4)
4 octets
16 cycles
Total :
6 octets
20 cycles
D:
move.1
d0,d1
2 octets
4 cycles
lsl.1
* 2,d1
2 octets
12 cycles
add.1
d1,d0
2 octets
8 cycles
add.1
d0,d0
2 octets
8 cycles
Total :
8 octets
32 cycles
E:
moveq
* 0,d0
2 octets
4 cycles
Dans l’exemple D, nous avons doublé la taille du code, mais réduit de moitié le temps d’exécution. Cette augmentation de taille (4 octets) est suffisa- ment négligeable pour préférer cette solution.
L’exemple C est une parfaite illustration d’une règle amusante de l’assembleur, qui veut que deux instructions s’exécutent parfois nlus rapidement qu’une seule, tout en prenant molr.s de place en mémoire !
Ce qui amène une septième règle importante:
Si vous pouvez utiliser MOVEQ pour des constantes 32 bits, FAITES-LE !
Cette règle s’applique à toute instruction dans laquelle il est possible d’utiliser un resgistre de donnée annexe. Par exemple:
and.1
* 15,d2
6 octets
16 cycles
or.1
* 2,d3
6 octets
16 cycles
sub.1
* 28,d4
6 octets
16 cycles
cmp.1
* 1,d1
6 octets
14 cycles
Total:
24 octets
62 cycles
beaucoup plus efficace écrit ainsi:
moveq
* 15,dO
2 octets
4 cycles
and.1
d0,d2
2 octets
8 cycles
moveq
* 2,d0
2 octets
4 cycles
or.1
d0,d3
2 octets
8 cycles
moveq
* 28,dO
2 octets
4 cycles
sub.1
d0,d4
2 octets
8 cycles
move.q
* 1,d0
2 octets
4 cycles
cmp.1
d0,d1
2 octets
8 cycles
Total :
16 octets
48 cycles
Bien sûr, il n’est pas obligatoire d’utiliser à chaque fois un registre. Il est toujours préférable, pour de petites valeurs, d’utiliser la variante QUICK des instructions. Bien que l’on puisse également ruser de ce côté-là:
sub.1 "10,dO 6 octets 16 cycles
sera avantageusement remplacé par:
subq.1 *8,d0 2 octets 8 cycles
subq.1 *2,d0 2 octets 8 cycles
Total: 4 octets 16 cycles
Une autre utilisation courante des constantes se retrouve dans les manipulations de la pile. Lorsqu’on appelle une routine en langage compilé, par exemple en C, qui requiert des paramètres sur la pile, il faut généralement la remettre “dans l’état où on l’avait trouvée en entrant". Ce qui ressemble souvent à:
add.1 *12,SP 6 octets 16 cycles
Pour une correction de 8 octets ou moins, il vaut mieux utiliser
addq.w *8,SP 2 octets 8 cycles
Mais pour neuf octets ou plus, l’instruction LEA est tout-à-fait appropriée:
lea 12(SP),SP 4 octets 8 cycles
Il ne faut pas se limiter à la simple instruction MOVEQ pour charger une constante dans un registre. Tout dépend bien sûr de la constante elle-même, mais il y a plusieurs astuces que l’on peut utiliser. Par exemple, pour charger une valeur de $ 10000 dans un registre, la première idée qui vient à l’esprit est: move.1 *$ 10000,dO 6 octets 12 cycles
alors qu’il est cent fois mieux d’écrire:
moveq *1,d0 2 octets 4 cycles
swap dO 2 octets 4 cycles
Total: 4 octets 8 cycles
Celà marche pour une valeur comprise entre $ FF800000 et $ 007F0000, où le mot de poids faible est à zéro.
Une autre astuce du même genre, lorsqu’on désire initialiser un registre avec une valeur trop grande pour l’instructeur MOVEQ:
moveq *200-256,d0 2 octets 4 cycles
neg.b dO 2 octets 4 cycles
Total: 4 octets 8 cycles
Le couple d’instructions MOVEQ NEG.B permet de charger n’importe quelle valeur 8 bits dans un registre de données. Ceci peut-être étendu à MOVEQ NEG.W pour des constantes comprises dans le domaine $ FFFF00xx à $ 0000FFxx.
Pour initialiser des constantes comprises entre $ 80000000 à $ 01000000, les instructions ROL et ROR offrent une alernative intéressante:
moveq *1,d0 2 octets 4 cycles
ror.1 *n,d0 2 octets 8+2n cydes
ou, pour les constantes comprises entre $ 00000080 et $ 00004000:
moveq *$ 40,dO 2 octets 8 cycles
rol.1 *n,d0 2 octets 8+2n cycles
Toutes ces petites astuces ne permettent d’économiser, finalement, que 2 octets et ou 4 cycles en moyenne. Mais en additionnant à chaque fois la place et le temps gagné dans un programme de plusieurs Ko, ce gain apparaît vite beaucoup plus appréciable.
Toutes les optimisations vues jusqu’ici ne s’appliquaient qu'aux registres de données, mais il existe des règles supplémentaires s’appliquant aux registres d’adresse.
Utiliser la forme .W chaque fois que possible.
Par exemple, pour charger une adresse constante dans aO, vous écririez peut-être:
move.1 *502,aO 6 octets 12 cycles
alors que l’instruction LEA s’avère bien meilleure: lea *502,W,a0 4 octets 8 cycles
Bien sûr, pour mettre à zéro un registre d’adresse, rien ne vaut l’instruction SUB:
sub.1 al,a1 2 octets 8 cycles
La forme .W de l’instruction PEA est très pratique pour empiler des valeurs dans le cas d’appel d’une fonction C. Au lieu d’utiliser:
Tmove.1 *1,-(SP) 6 octets 20 cycles
ou même:
moveq *1,d0 2 octets 4 cycles
move.1 d0,-(SP) 2 octets 12 cycles
Total: 4 octets 16 cycles
il vaut mieux écrire:
pea 1.w 4 octets 16 cycles
Ceci ne présente pas d’avantage particulier par rapport à la seconde méthode, du moins pour les petites constantes que MOVEQ accepte (si ce n’est d’éviter la frappe d’une ligne de code source! Amis fainéants, bonjour). Par contre, pour les constantes 16 bits, on y gagne beaucoup. Sur un 68020 ou un 68030, l’instruction MOVEQ est encore plus rapide, grâce au système de “pipelining” utilisé dans ces processeurs; vous avez donc à utiliser la seconde méthode chaque fois que possible.
Sur l’Amiga, un problème courant avec les registres d’adresse, est la conversion de pointeurs BPTR en pointeus APTR (NDLR: un pointeur de type BPTR vous vient tout droit du langage BCPL, avec lequel a été écrit une petite partie du système d’exploitation de l’Amiga, notamment quelques librairies. Un pointeur de type APTR est quant à lui en provenance direct du langage C). Un pointeur BPTR se distingue par le fait qu’il est décalé de deux bits vers la droite, opération impossible sur un registre d’adresse. La première solution venant à l’esprit est donc: exg aO.dO 2 octets 6 cycles
lsl.1 *2,d0 2 octets 12 cycles
exig d0,a0 2 octets 6 cycles
Total: 6 octets 24 cycles
Même en utilisant une instruction MOVE.L au lieu d’EXG (ce qui soit dit en passant perd le contenu de dO), on ne gagne que quatre cycles. C’est pourquoi il vaut mieux écrire:
add.1 a0,a0 2 octets 8 cycles
add.1 a0,a0 2 octets 8 cycles
Total: 4 octets 16 cycles
(un décalage de deux bits vers la droite revient en effet à multiplier par quatre).
Il existe certainement d’autres optimisations possibles en assembleur 68000, mais ce sont là les plus courantes. La meilleure manière de les retenir, et même d’en apprendre d’autres est encore d’avoir un livre officiel de chez Motorola indiquant pour chaque instruction le temps d’exécution.
Quoiqu'il en soit, tout ceci ne représente qu’une petite partie de ce qu’il est possible de faire pour optimiser un programme entier. Il existe d’autre moyens que de bêtes substitutions d’instructions.
Le mois dernier, nous avons vu dans le détail huit commandes (ASSIGN, CD, C0PY, DELETE, DIR, ED, MAKEDIR, RESIDENT). Il s’agit désormais de les utiliser avec discer
nement.
uvrir une fenêtre SHELL et taper des commandes au hasard peut se reveler très instructif, mais cela peut aussi représenter du temps de perdu. Après tout, cette rubrique a pour but de vous aidez à profiter de votre superbe Amiga en ôtant au SHELL ce caractère mystérieux fort rebutant. En d’autres mots, elle vise à vous faire dominer un outil. Elle tente aussi de vous rendre plus productif en ne se contentant pas de commenter les commandes AmigaDos, mais en exposant comment, par l’enchaînement de commandes AmigaDos dans un fichier script, vous pouvez rendre aisées des taches complexes. Assez de bla-bla, passons aux choses sérieuses :
Tentons aujourd’hui de résoudre un problème courant, celui de l’installation et du paramétrage d’une imprimante. L’utilisateur, qui découvre sa machine, fait en général relativement tôt connaissance avec le programme Préférences. En pénétrant dans le tiroir PREFS, il découvre de nombreux icônes dont la fonction est relativement simple à comprendre : le programme Preferences est le programme principal, et les icônes Pointer, Printer et Serial permettent d’accéder directement dans le programme Preferences aux paramètres qui l’intéressent. Les petits futés pourront en sélectionnant un de ces icônes, et en chois- sissant la fonction Info du menu Workbench se convaincre de la chose. Lorsqu’il a lance le programme Preferences, cet utilisateur expérimente avec les couleurs de l’écran du Workbench, il change l’heure, il modifie le pointeur, et procède ainsi à toutes sortes de petits réglages. Arrive le moment où il est confronté avec l’écran de séléction de l’imprimante = = Printer = =. Pour ne rien vous cacher, il n’est pas rare qu’il y rencontre sa première déconvenue.
Pourquoi ? Parceque son imprimante est rarement présente dans la liste des imprimantes disponibles qu’il fait défiler. Oh, il peut bien choisir le port de connection de l’imprimante (SERIAL ou PARALLEL), il peut spécifier la longueur de son papier comme spécifique (CUSTOM) et égale à 66 lignes, il peut choisir des marges gauche (1) et droite (80), il peut indiquer sa preference pour la qualité courrier (LETTER) ou la qualité brouillon (DRAFT), Il peut retenir un texte espacé avec 6 lignes par pouce (6 LPI) ou un texte dense avec 8 lignes par pouce (8 LPI), il peut encore sélectionner une police de caractères standard (10-PICA) ou compressée (15-FINE) ou établir que le papier est continu (FANFOLD) ou introduit manuellement feuille à feuille (SINGLE). Mais si il ne peut choisir son imprimante, il devra se contenter de l’imprimante = = générique = = qui ne propose aucune fonctionnalité évoluée (polices de caractères, gras, souligné, double largeur,...).
Commodore pour expliquer pourquoi il n’y a que le gestionnaire minimum (generic) sur un Workbench : en effet la disquette Workbench était déjà fort pleine, et que cela n’avait pas de sens de chercher à y mettre tous les drivers puisque les utilisateurs ont rarement à leur disposition plus d'une ou de deux imprimantes. Les gestionnaires ont été regroupés dans le répertoire devs printers de la disquette EXTRAS 1.3. De plus un mécanisme automatique par un programme AmigaDos est fourni pour faciliter le transfert (nous y reviendrons plus tard).
Régler les préférences sur la bonne imprimante est primordial pour des impressions sans tracas, car l’Ami- gaDos et tous les programmes d’applications vont y faire référence. En effet, si il est toujours possible d’adresser directement les ports série et parallèles de l’ordinateur (aux doux noms de SER : et PAR :), il est beaucoup plus simple et performant pour l’utilisateur comme pour les programmes d’utiliser l’imprimante système du nom de PRT :. Cette imprimante aux capacités extraordinaires (couleurs, graphismes, polices,...) reçoit les données à imprimer et, grâce aux paramètres de préférences, les convertit dans le lan- guage de commandes compréhensible par l’imprimante physique connectée au système. La relative complexité de cet ensemble n’en n’a pas facilité la mise au point, la version 1.3 apporte de très nombreuses améliorations au prix de l’incompatibilité des gestionnaires, veillez donc à ne pas mélanger les différentes versions !
Pour pouvoir disposer du gestionnaire de l’imprimante adaptée, un certain nombre d’étapes sont nécessaires. Il convient d’identifier le gestionnaire d’imprimante approprié à votre imprimante ; ce n’est pas toujours évident car parfois celle-ci ne fait pas partie des imprimantes reconnues par Commodore, dont voici la liste obtenue par un :
DIR EXTRAS1.3 devs printers :
Alphacom Alphapro 101Brother HR-15XL
CalComp ColorMaster CalComp_ColorMaster2
Canon PJ-1080A CBM_MPS1000
Diablo_630 Diablo_Advantage_D25
Diablo_C-150 EpsonQ
EpsonXOld EpsonX°CBM MPS-12
50§
Howtek Pixelmaster HP DeskJet
HP LaserJet HP_PaintJet
HP ThinkJet Imagewriterll
Nec Pinwriter Okidata 293I
Okidata 92 Okimate_20
Quadram_QuadJet Qume__LetterPro_20
Toshiba P351C Toshiba_P351SX
Xerox 4020
Cependant, il ne faut pas s’affoler, car les constructeurs d’imprimantes prennent rarement le risque de construire une imprimante munie d’un jeu de commandes particulier. Les imprimantes sont ainsi dotées de modes de compatibilités, qui au moyen d’un réglage des micro-interrupteurs leur permet de reconnaître et d’exécuter un jeu de commandes plus standard. Ainsi, toute la gamme des Epson 24 aiguilles reconnaît les mêmes commandes, ce qui a conduit Commodore à ne proposer qu’un seul programme d’interface (ou gestionnaire ou encore = = driver = =), celui dénommé EpsonQ. Pour la même raison le driver CBM-MPS1000 convient à la majorité des imprimantes 9 aiguilles pour compatibles IBM-PC, et le driver HP_LaserJet donne toute satisfaction a jx possesseurs d’une imprimante compatible H P__LaserJet et
HP LaserJet +. En cas de doute, seul le procédé des
essais et des erreurs vous permettra de sélectionner le driver le plus adapté.
Une fois le driver identifié, il faut le trouver et l'installer. Pour l’installer, il faut bien sûr disposer d'un peu de place sur son disque système, qui est soit votre copie de travail du Workbench, soit votre disque dur. Pour vérifier l’espace disponible, tapez la commande CLI INFO qui vous fournira l’espace disponible sur les mémoires de masse de votre système.
Voici le résultat de cette commande sur mon système A2000A équipé de 1,5 Moctets de mémoire vive, d’une carte passerelle, d’un disque dur de 20 Moctets partagé entre MS- DOS et AmigaDos et d’un lecteur externe.
Mounted disks :
Unit Size Used Free Full Errs Status Name JHO : 15M 28083 3127 89 % 0 Read Write SYS(jhO)
DF2: 880K 1745 13 99 % 0 Read Write Extrasl.3
DFO: 880K 1753 5 96 % 0 Read Only
Workbench1.3
RAM: 24K 48 0100 % 0 Read Write RAM DISK
Volumes available :
Workbench1.3 [Mounted]
Extras 1.3 [Mounted]
RAM DISK [Mounted]
SYS(jh0) [Mounte]
Comme vous pouvez le constater, ma copie du Workbench est protégée en écriture (merci, les virus) et dispose de 5 blocs libres. Un rien d’arithmétique nous permet de savoir que nous disposons de seulement 2,5 Koctets d’espace disponible. Pour installer un gestionnaire d’imprimante, il est prudent de disposer d’une dizaine de Koctets, en conséquence il faut faire de la place sur la disquette. Le moyen le plus simple consiste à visionner le contenu de la disquette de manière interactive : tapez donc la commande DIR DFO : INTER.
Elle va vous afficher les répertoires et les fichiers suivis d’un point d’interrogation qui symbolise l’attente d’une commande de l’utilisateur. Les commandes que la commande DIR en interactif comprend sont : retour- chariot pour passer au répertoire ou au fichier suivant E pour rentrer dans le répertoire B pour sortir du répertoi e et remonter d’un niveau Q pour arrêter la commande dir C pour taper une comma de CLI T pour afficher le contem d’un fichier DEL pour effacer le fichior.
C’est cette commande DEL qui nous sera la plus utile. En explorant la structure de votre disquette, je vous recommande de noter tous les noms de fichiers qui vous intriguent pour lire dans les notices ou dans les précédents exemplaires de Commodore Revue, les explications. Je vous prévient immédiatement que vous trouverez des quantités importantes de
Pour développer vite (très vite) et bien, pour que programmation rime avec plaisir, voici le GFA BASIC 3.0 AMIGA.
LE LANGAGE QUI DÉMODE LES AUTRES.
Gfê. 3
AMIGA
Il réunit la puissance d'un langage structuré à la simplicité d'utilisation d'un Basic. Récursif, il est tout aussi doué pour les applications ludiques que professionnelles.
Sa capacité à tirer le meilleur profit des possibilités hardware de l'AMIGA, ses 400 fonctions, sa grande rapidité d'exécution et d'interprétation vous permettent de donner désormais libre cours à votre imagination.
La programmation en langage structuré, SELECT, CASE, DO...LOOP, WHILE..., ELSE IF..., garantit à vos programmes concision, clarté et rapidité : menus déroulants, correction syntaxique, compteur de ligne, indentation automatique, fonctions puissantes de débogage, pliage des procédures (folding), accès aux comman- des du CLI, raccourcis clavier pour l'ensemble des § fonctions...
a
GFA BASIC 3.0 gère de manière simple ce qui ne l'est pas : les outils de l'interface INTUITION (menus, fenêtres, boîtes de dialogue...), les accès disque, la gestion des fichiers, les interruptions, les entrée sortie... Des commandes très courtes permettent au GFA d'appeler toutes les fonctions essentielles de l'AMIGA. Vous pourrez même l'interfacer avec le langage C ou l'Assembleur.
Enfin GFA BASIC 3.0 calcule vite, très vite (13 chiffres après la virgule) et propose un éventail de fonctions unique dans son domaine : accès aux répertoires, tri dans les tableaux, manipulation de bits, opérations sur les entiers...
GFA BASIC 3.0 AMIGA, c'est une révolution !
R
EDITIONS MICRO IPPLICATION
58, rue du Faubourg-Poissonnière 75010 PARIS Tél.: (1) 47703244
? Je désire recevoir GFA BASIC 3.0. Ci-joint mon règlement de 750 F par :
O mandai d chèque â l'ordre de MICRO APPLICATION
Date d'expiration :___
Code postal _ Signature
fichiers.info de faible taille. Il s’agit du graphisme associé à un fichier, à un répértoire ou à une disquette, ne l’effacez qu’en connaissance de cause. Lors de votre descente aux enfers, pardon, descente dans la structure d’une disquette, vous rencontrerez sûrement mon favori, le programme EDIT contenu dans le répertoire C des commandes AmigaDos.
Ce programme de 18164 octets est un affreux éditeur de texte ligne à ligne dont les origines remontent aux débuts de l’informatique. Il ne présente aucune utilité (sauf dans l’usage hyper spécifique exposé dans le jeu de NIM programmé en AmigaDos) ; c’est donc un favori pour l’effacement. Les personnes les plus pressées peuvent décider de me faire confiance, et de taper la commande CLI DELETE DFO :C EDIT plutôt que d’arpenter la disquette.
Parvenu à cet endroit de l’article, vous souvenez- vous de l’objectif visé ? Peut-être pas. Je vous rappelle donc le but de la manœuvre : installation d’un gestionnaire d’imprimante et les étapes que nous avons franchies :
paramétrage de Préférences choix d’un gestionnaire d’imprimante nettoyage de la disquette système.
Il nous reste donc à transférer le gestionnaire depuis le répertoire devs printers de la disquette Extras1.3. Attention, les possesseurs d’un seul lecteur doivent passer par une étape intermédiaire visant à rendre residentes des commandes AmigaDos pour pouvoir manipuler les fichiers de la disquette Extras sans devoir ré-insérer la disquette Workbench ; il leur faut donc taper :
RESIDENT C :DIR pure add RESIDENT C :COPY pure add.
Faisons donc d’abord une vérification CD EXTRAS1.3 : devs printers (pour se positionner dans le répertoire DIR pour avoir la liste des drivers). COPY driver-choisi DEVS : printers (pour le copier dans le répertoire système approprié).
CD SYS : Prefs (pour aller dans le répertoire des programmes de gestion des préférences). PREFERENCES (pour lancer le programme proprement dit, il peut être éxecuté depuis un CLI ou depuis le Workbench). Sélectionnez le type de l’imprimante et procédez à des choix dans les domaines de l’impression graphique.
COPY S Startup-sequence PRT : (pour réaliser un test en imprimant un fichier depuis le CLI, ou vous pouvez aussi vous servir de NOTEPAD pour tester les modes graphiques (testez notamment l’impact de l’option SCALING = INTEGER de l’écran 2 pour l’impression graphique de Preferences).
EXECUTE COPYPREFS (ou cliquez sur l’icône) si vous disposez d’un disque dur, car le programme Preferences modifie le fichier de configuration SYS : devs system-configuration qui est situé sur le disque dur, et non celui qui est présent sur la disquette de démarrage ; si Preferences est initialisé au démarrage avec un fichier, puis est lancé avec un autre fichier de configuration, le conflit va lui faire oublier les deux configurations.
En fait, cette procédure a été automatisée par un utilitaire écrite sous AmigaDos par les ingénieurs de
Commodore. Ouvrez en effet le tiroir UTILITIES de votre Workbench, vous découvrirez une icône nommée Ins- talIPrinter. Avec la commande INFO du menu Workbench, vous découvrirez que ce fichier de données (le TYPE de l’icône est PROJECT) renvoit à un programme C :lconX mentionné comme l’outil de prédilection (TOOL). Lorsqu’on clique sur un projet, le Workbench examine le fichier.info qui contient le graphisme de l’icône et les informations d’INFO, et détermine quel programme peut s’exécuter sur les données contenues dans le fichier. IconX,présent dans le répertoire des commandes, est une sorte d’équivalent à la commande Exécuté : il ouvre une fenêtre (ici définit dans l’information TOOL TYPE :
Window = NewCon 0 2 640 192 lnstallPrinter) et fait exécuter dans cette fenêtre les commandes AmigaDos contenues dans le fichier.
Ces commandes sont ici reproduites :
.key ” ”
indique au CLI qu’il faut opérer une substitution de paramètre, même si il n’y a aucun argument admissible a la commande ” ”, les caractères §§ seront remplacés par le numéro du processus CLI qui exécute la procédure (on continue de l’appeler CLI, alors qu’en fait c’est un processus SHELL puisque la commande RESIDENT CLI L :SHELL-SEG System pure add remplace les appels au CLI par des appels au SHELL .bra
.ket )
les identifiants de paramètres sont désormais ) au lieu des habituels >, et ceci pour permettre l’utilisation de la redirection des entrées-sorties from ( }$ $ : ” ’’
donne le nom fromn : au répertoire courant, ou n est le numéro du processus CLI qui exécute la procédure
résident c :copy add pure résident c :dir add pure résident c :echo add pure résident c :setenv add pure
installe quatre commandes en résidence pour pouvoir se passer en partie de la disquette Workbench durant la procédure
failat 21
seuls les codes d’erreurs supérieurs à 20 pourront provoquer l’arrêt de la procédure, et comme les procédures AmigaDos renvoient 0 pour OK, 5 pour avertissement, 10 pour erreur et 20 pour erreur grave, on est sûr de ne pas s’arrêter en catastrophe
lab y lab yes
deux addresses de retour echo ”*Ec *E[4mPrinter Install Program*N*N*E[OmPrinters Available :*N”
affiche une jolie ligne de présentation cd "Extras 1.3 :devs printers”
se positionne dans le répertoire des gestionnaires IF error
si le code d’erreur est > 20, l’utilisateur n’a pas inséré le volume EXTRAS 1.3, et a cliqué sur CANCEL lorsqu’on le lui a demandé, il convient donc de s’arrêter.
Skip err
l’exécution continue à l’adresse err
ENDIF
dir
affiche le contenu du répertoire courant, c’est-à- dire la liste de toutes les imprimantes
echo ”*NWhich printer? (press RETURN to exit)” noline
affiche la ligne sans passer à la suivante, l’interrogation de l’instruction suivante sera donc collée à ce texte
setenv >NIL : q($ $ ) ?
attend l’entrée d’une chaîne de caractères dans la variable qn ou n ets le numéro du CLI, cette variable est stockée dans le fichier ENV :qn
IF$ q $ $ j” ”
si la chaîne est vide, on arrête skip err
ENDIF
echo > >env :q|$ $ | ” to devs rprinters”
concatène à la chaîne de caractères (qui contient le nom du gestionnaire souhaité) le répertoire de destination
echo ”Now copying your printer choice to devs :prin- ters.”
petit message informatif copy env :q j $ $ ) > NIL : ?
exécute la commande COPY avec la chaîne de caractères complète comme argument (utilisation du signe ? Pour indiquer à la commande qu’elle doit attendre la suite des arguments, utilisation du signe pour donner cette suite non pas à partir de l’entrée standard, mais à partird’un fichier, et utilisation du signe pour envoyer les messages d’aide de la commande COPY générés par l’emploi du ? Dans un trou sans fond, le périphérique NIL:)
IF error
en cas d’erreur
echo ”Error during copy. Do you want to try again ?” noline
message informatif skip > NIL : back ?
la commande SKIP attend son paramètre (à cause du signe ?) En n’affichant pas de message (en raison du > NIL :), grâce au paramètre BACK, la commande SKIP peut reveniren arrière ; il y a ici une astuce particulière, la commande SKIP demande en fait à l’utilisateur l’adresse à laquelle le programme doit sauter alors que l’utilisateur croit répondre a une question normale, ainsi si il répond Y ou YES pour recommencer, le programme recommence à l’adresse Y ou YES, si l’adresse est différente SKIP va la chercher dans tous le fichier
ELSE
tout s’est bien passé
echo ”Now choose this printer using Preferences.”
encore un message qui rappelle l’importance du programme
Preferences ENDIF lab err
adresse pour les erreurs endskip
la commande SKIP n’ira pas plus loin, même si elle n’a pas trouvé d’adresse correspondant au choix de l’utilisateur (par exemple, si il a tapé autre chose que Y ou YES)
cd from|$ $ ) :
on revient au répertoire de départ assign from|$ $ ) :
on efface le nom fromn : résident copy remove résident dir remove résident echo remove résident setenv remove
on retire de la liste des commandes résidentes les commandes précédemment pré-chargées, on retrouve donc de la mémoire au détriment de la vitesse d’accès et de l’indépendance par rapport au Workbench.
B. de Mille
ViewPort
EAGLE’S RIDER
Cet été, l’effervescence règne à Vitry sur Seine, dans les locaux de Microïds. Non pas à cause du nombre élevé de cachets d’aspirine qui circulent (quoique...), mais plus simplement parce que l’on prépare la rentrée d’arrache-pied.
W armi les nouveautés attendues, on trouve Chicago 90, un jeu de poursuite en ville, dans lequel le joueur peut choisir d’incarner soit les méchants (les voleurs), soit les gentils (la police). Dérapages contrôlés et cascades diverses devraient être de la partie.
Highway Patrol est quant à lui un véritable simulateur de conduite en 3D, concurrent direct de Crazy Cars II. Le joueur incarne un policier américain à la poursuite d'une bande de gangsters. Une carte routière détaillée est fournie dans le packaging.
Blue Angles est encore un simulateur 3D, mais de vol cette fois-ci. A la différence d’autres jeux comme F18 Interceptor ou Falcon, pour ne prendre que les plus récents, Blue Angels vous propose un vol en formation. D’ailleurs, les Blue Angels sont l’équivalent américain de notre bonne vieille Patrouille de France. Le but du jeu, en tant que pilote novice, est de parvenir à intégrer la formation. Ce jeu est entièrement patronné par les véritables Blue Angels, qui se sont même amusés à censurer quelques scènes (notamment celle du crash) ! Voilà qui promet.
Mais celui qui a le plus retenu notre attention est Eagle’s Rider, un jeu d’arcade aventure qui devrait faire parler de lui. Le scénario place le joueur en l’an 7014, où le capitaine Steve Jordan de la 537ème escadrille de chasseurs-intercepteurs des FHU (Force Humaines Unifiées, en guerre contre les cyborgs) s’évade de sa prison militaire à bord du tout nouveau chasseur « Eagle ». Son but est tout simplement d’aller détruire la planète mère des Cyborgs !
Le graphiste, Cedric Cazal, a réalisé un véritable dessin animé de trois minutes ( !) Qui sert d’introduction au jeu. On y voit Jordan moisir dans sa prison, assommer son gardien venu lui apporter à manger, s’enfuir à grandes enjambées sous les lasers des cyborgs, voler un « Eagle » pour finalement décoller de la planète, le tout accompagné d’une musique parfaitement synchronisée avec les images. Je n’ai pu en apprécier pour l’instant que la version Atari ST, mais elle était déjà époustoufflante. La version Amiga devrait être encore meilleure, assure-t-on du côté de Microïds ; on veut bien les croire !
Eagle’s Rider est divisé en deux parties. Dans la première, la partie arcade, Jordan est aux commandes de l’Eagle et doit rejoindre la station galactique la plus proche pour y trouver tous les éléments nécessaires à la bonne marche de sa mission. Champs de météorites, orages magnétiques, trous noirs et pirates de l’espace sont autant d’épreuves à surmonter.
Dans la seconde partie, la partie aventure, Jordan doit découvrir les coordonnées de la planète mère des cyborgs et aller la détruire. Ces informations lui seront communiquées par les personnages qu’il pourra contacter tout au long du jeu. Les dialogues se font entièrement par l’intermédiaire de la souris et de la synthèse vocale.
Les images et quelques routines en cours de développement que j’ai pu voir sont plutôt prometteuses. La page de garde (en ray-tracing animé !) Mérite a elle toute seule que l’on raconte son histoire.
L’Eagle a été dessiné et animé avec Sculpt Animate 4D. L’animation comporte quand même quelques 60 images, au cours desquelles on voit le vaisseau tourner sur lui-même, devenir lentement filaire, avant de reprendre sa forme pleine. Tout simplement fabuleux.
Encore une fois, tous nos 1® n®tr >tit fa sympathi-
nuelForsans, Laurent Genelot et touieia y
que équipe de Microïds. Stéphane Schreiber
Le revers de la médaille étant bien entend,, io mémoire occupée par une telle animation. Pou qu'eîie puisse également tourner sur un Amiga 500 il fallai? Ruser... Meme en compactant à l'aide d’un algorithme hyper performant, ça ne rentrait toujours oas dan? 512 Ko. Finalement, la solution retenue fut de retra vailler individuellement chacune des 60 imaoes aIPr' PixMate (pour virer quelques plans de bits sans trop perdre de couleurs), puis de les assembler à nouveau en un fichier au format Sculpt Animate 4D afin oue ce dernier puisse sauver une animation que son player soit capable d’afficher ! Un travail de jonqlaae énorme
mais le résultat en valait la peine. ’
La musique quant à elle a été composée à Bordeaux par un groupe de rock local et sous SoundTracker Et croyez-moi, elle assure un max ! Pour ceux qui connaissent SoundTracker, les sons utilisés, et plus particulièrement la guitare rock, sont superbes...
CADEAU SURPRISE
Scoop, événement et toutes ces sortes de choses : le programmeur Laurent Genelot et le chef de développement Emmanuel Forsans, ont gentimment accepté de nous livrer à des fins de publication, une routine utilisée dans Eagle Rider.
Il s’agit du ciel étoilé de la partie arcade du jeu. Contrairement à ceux que vous avez l’habitude de voir, notamment dans les démos, les étoiles de se contentent pas de défiler sur le côté, elles arrivent du centre de l’écran et partent en accélérant jusqu’au bord, donnant l’impression d’un déplacement en ligne droite à grande vitesse.
Le listing fourni est prévu pour l’assembleur Dev- pac, mais son adaptation à un autre assembleur (Meta- comco, K-Seka, A68K, etc.) ne devrait théoriquement poser aucun problème.
Ont> La musique quant à elle a été composée à Bordeaux par un groupe de rock local et sous SoundTracker Et croyez-moi, elle assure un max ! Pour ceux qui connaissent SoundTracker, les sons utilisés, et plus particulièrement la guitare rock, sont superbes...
CADEAU SURPRISE
Scoop, événement et toutes ces sortes de choses : le programmeur Laurent Genelot et le chef de développement Emmanuel Forsans, ont gentimment accepté de nous livrer à des fins de publication, une routine utilisée dans Eagle Rider.
Il s’agit du ciel étoilé de la partie arcade du jeu. Contrairement à ceux que vous avez l’habitude de voir, notamment dans les démos, les étoiles de se contentent pas de défiler sur le côté, elles arrivent du centre de l’écran et partent en accélérant jusqu’au bord, donnant l’impression d’un déplacement en ligne droite à grande vitesse.
Le listing fourni est prévu pour l’assembleur Dev- pac, mais son adaptation à un autre assembleur (Meta- comco, K-Seka, A68K, etc.) ne devrait théoriquement poser aucun problème.

Click image to download PDF

AMIGA NEWS TECH numero 04 (09-1989)

Merci pour votre aide à l'agrandissement d'Amigaland.com !


Thanks for you help to extend Amigaland.com !
frdanlenfideelhuitjanoplptroruessvtr

Connexion

Pub+

55% 
9.7% 
3.9% 
3.2% 
3.1% 
2.6% 
2.3% 
1.2% 
0.9% 
0.9% 

Yesterday: 88
This Week: 605
Last Week: 645
This Month: 1799
Last Month: 2867
Total: 77187

Information cookies

Cookies are short reports that are sent and stored on the hard drive of the user's computer through your browser when it connects to a web. Cookies can be used to collect and store user data while connected to provide you the requested services and sometimes tend not to keep. Cookies can be themselves or others.

There are several types of cookies:

  • Technical cookies that facilitate user navigation and use of the various options or services offered by the web as identify the session, allow access to certain areas, facilitate orders, purchases, filling out forms, registration, security, facilitating functionalities (videos, social networks, etc..).
  • Customization cookies that allow users to access services according to their preferences (language, browser, configuration, etc..).
  • Analytical cookies which allow anonymous analysis of the behavior of web users and allow to measure user activity and develop navigation profiles in order to improve the websites.

So when you access our website, in compliance with Article 22 of Law 34/2002 of the Information Society Services, in the analytical cookies treatment, we have requested your consent to their use. All of this is to improve our services. We use Google Analytics to collect anonymous statistical information such as the number of visitors to our site. Cookies added by Google Analytics are governed by the privacy policies of Google Analytics. If you want you can disable cookies from Google Analytics.

However, please note that you can enable or disable cookies by following the instructions of your browser.

Visitors

Visite depuis
03-10-2004
Visite depuis
23-02-2014