Sponsors

FacebookTwitterGoogle Bookmarks

Le contenu de cet article est un défi, il s’agit d’un jeu traditionnel en informatique et en théorie des jeux : le jeu de NIM. Il fut complètement programmé en commandes AmigaDos, dans un fichier « script » qui décrit la séquence des instructions à effectuer. Il met en œuvre une douzaine de programmes de l’AmigaDos, pour questionner l’utilisateur, simuler le hasard, appliquer une tactique et présenter les résultats. Il a été facilement conçu dans l’esprit d’AmigaDos (et d’Unix, avouons-le), où il est parfois plus aisé de structurer plusieurs petits programmes utilitaires pour fournir un service, que de réaliser, à partir de zéro, un programme qu’il faudra tester, diffuser et maintenir. Avant d’aller plus loin, je vais vous rafraîchir la mémoire sur ce jeu, auquel vous avez sûrement joué. Il oppose deux joueurs qui, chacun à leur tour, vont retirer un ou plusieurs objets (des allumettes dans mon folklore personnel) d’un tas constitué au départ. Le perdant est celui qui est contraint de retirer le dernier objet. De manière éxpérimentale ou par le raisonnement, on s’aperçoit rapidement qu’en fonction du nombre d’allumettes et de la taille de la poignée (quantité maximale licite d’objet à retirer), l’un des joueurs a une stratégie gagnante, c’est à dire qu’il peut gagner quelque soit celle adoptée par son adversaire. Je ne dévoilerai pas ici les secrets (sic) de cette stratégie, mais le programme est construit de telle manière que les paramètres : premier joueur, importance du tas initial et taille de la poignée varient pour conserver un attrait au jeu. Si les principes du jeu sont facilement programmables en théorie, je ne vous cacherai pas qu’il faut se livrer à de nombreuses contorsions intellectuelles et programmatiques pour le bâtir exclusivement en AmigaDos. Mais c’est par cet usage aux limites de ses possibilités, que nous pourrons mieux utiliser les possibilités de l’AmigaDos dans une utilisation plus « tranquille ». De plus, en mettant à jour des lourdeurs ou des incohérences, nous pouvons dès aujourd’hui améliorer nos procédures d’exploitation, en ayant recours aux trucs exposés dans ces pages, mais je pense que nous défrichons aussi pour les futurs AmigaDos.

Click image to download PDF

AMIGA NEWS TECH numero 02 (06-1989)

Document sans nom Les ressources du SHELL 1.3
L AmigaDos a, paraît-il, rebuté bon nombre de personnes par son aspect rébarbatif et ses commandes peu intuitives. Les articles de cette série (diffusés en clair, tous les mois dans Commodore revue) ont pour objectifs de démystifier l’AmigaDos. Après les principes de l’AmigaDos et les mystères des fichiers de démarrage, après les notes sur les SHELL, il est temps de se mettre à l’ouvrage. Pour ceux qui n’étaient pas avec nous le mois dernier, qu’ils n’hésitent pas à se procurer, soit les numéros précédents, soit le manuel de l’AmigaDos 1.3 chez Micro- Application, soit encore le très rare « Enhancer
1. 3 Français » de Commodore.
Le contenu de cet article est un défi, il s’agit d’un jeu traditionnel en informatique et en théorie des jeux : le jeu de NIM. Il fut complètement programmé en commandes AmigaDos, dans un fichier « script » qui décrit la séquence des instructions à effectuer. Il met en œuvre une douzaine de programmes de l’AmigaDos, pour questionner l’utilisateur, simuler le hasard, appliquer une tactique et présenter les résultats. Il a été facilement conçu dans l’esprit d’AmigaDos (et d’Unix, avouons-le), où il est parfois plus aisé de structurer plusieurs petits programmes utilitaires pour fournir un service, que de réaliser, à partir de zéro, un programme qu’il faudra tester, diffuser et maintenir. Avant d’aller plus loin, je vais vous rafraîchir la mémoire sur ce jeu, auquel vous avez sûrement joué. Il oppose deux joueurs qui, chacun à leur tour, vont retirer un ou plusieurs objets (des allumettes dans mon folklore personnel) d’un tas constitué au départ. Le perdant est celui qui est contraint de retirer le dernier objet. De manière éxpérimentale ou par le raisonnement, on s’aperçoit rapidement qu’en fonction du nombre d’allumettes et de la taille de la poignée (quantité maximale licite d’objet à retirer), l’un des joueurs a une stratégie gagnante, c’est à dire qu’il peut gagner quelque soit celle adoptée par son adversaire. Je ne dévoilerai pas ici les secrets (sic) de cette stratégie, mais le programme est construit de telle manière que les paramètres : premier joueur, importance du tas initial et taille de la poignée varient pour conserver un attrait au jeu. Si les principes du jeu sont facilement programmables en théorie, je ne vous cacherai pas qu’il faut se livrer à de nombreuses contorsions intellectuelles et programmatiques pour le bâtir exclusivement en AmigaDos. Mais c’est par cet usage aux limites de ses possibilités, que nous pourrons mieux utiliser les possibilités de l’AmigaDos dans une utilisation plus « tranquille ». De plus, en mettant à jour des lourdeurs ou des incohérences, nous pouvons dès aujourd’hui améliorer nos procédures d’exploitation, en ayant recours aux trucs exposés dans ces pages, mais je pense que nous défrichons aussi pour les futurs AmigaDos.
Assez parlé, place au listing (les commandes et leurs paramètres sont en majuscules, les arguments sont en minuscules, tout ce qui est après un point virgule est un commentaire ignoré par l’intérpréteur de commandes, il est donc inutile de taper ce qui suit ces points virgules).
Cecil B. de MIL
: Initialisation FAILAT 30
: a oour but de modifier le niveau d’erreur fatal
; oour permettre de charger les commandes suivantes en
; résident sans Planter le script si elles le sont déjà
RESIDENT c : if PURE
RESIDENT c:else PURE
RESIDENT c:endif PURE
RESIDENT c:echo PURE
RESIDENT c:eval PURE
RESIDENT c:lab PURE
RESIDENT c: skie PURE
RESIDENT c:setenv PURE
RESIDENT c:getenv PURE
RESIDENT c:ask PURE
RESIDENT crédit PURE
RESIDENT e : date PURE
RESIDENT c:copy PURE
RESIDENT c:delete PURE
: les commandes réexécutables et réentrantes peuvent être : chargées une fois pour toute en mémoire oour en : accélérer l’exécution FAILAT 10
; le code d’erreur fatal au script est rétabli A sa : valeur par défaut 10
SETENV commence H
: cette variable d’environnent contient un type oui : correspond au premier Joueur
ECHO >t:commandedit "dta 1 : "
ECHO >>trcommandedit "a'
: ce fichier va contenir des instructions oour l'éditeur : de textes qui permettront d’isoler les secondes dans la ; chaîne de caractères renvoyée par la commande DATE
IF NOT EXISTS env:scorel
; si on n’a jamais joué, les scores stockés dans des ; variables d’environnement conservées entre chaque appel ; au programme sont initialisés SETENV scorel 0 SETENV score2 0
ENDIF
Boucle principale LAB début
; marque la destination d’un saut par la commande SKIP
ECHO " *N *e*33mJEU de NIM en AmigaDos SHELL*e“Om*N"
; la commande ECHO accepte des caractères de contrôle ECHO "Les règles sont simples
ECHO “Chaque joueur retire de la pile, un ou plusieurs octets.'
ECHO "Celui qui retire le dernier a perdu !!"
ECHO "Pour ajouter de la variété, on doit choisir le nombre ECHO "maximal de jetons qu’un joueur peut retirer."
ECHO "Alternativement, c’est l’ordinateur et l’humain"
ECHO "qui commencent.*N*N"
ECHO “Votre score : “ NOLINE
GETENV scorel
; GETENV renvoie le contenu de la variable d’environnement ECHO "Celui de l’ordinateur : " NOLINE GETENV score2
ECHO "*NVoule2-vous faire une partie "
ASK "Y pour continuer, N ou touche RETURN pour stopper"
IF NOT WARN
; ASK renvoie un code UJARN d’erreur bénigne si on lui
; répond Y ou YES et renvoie un code OK si on lui répond
; autrechose
SKIP fin
ENDIF
LAB choixdegré
ECHO "A quel degré voulez-vous jouer (de 2 ?” NOLINE
SETENV > ni 1 : degré ?
; SETENV donne une valeur à une variable d’environnement,
; ici on utilise des indirections pour rendre la commande ; interactive et ne cas afficher la fonction d’aide
IF Sdegre NOT GT 1 VAL
; observez la syntaxe d’un test sur des valeurs numériques : contenues dans l’environnement ECHO "Trop petit"
SKIP choixdegré BACK
ENDIF
IF Sdegrê GT 6 VAL
ECHO "Trop grand"
SKIP choixdegré BACK
ENDIF
ATTENTION, en raison de la syntaxe de la commande EVAL, il a fallu avoir recours à de nombreuses astuces pour pouvoir calculer les valeurs qui nous intéressent elle accepte les paramètres suivants ivaleurl. Valeur2. Destination (TO). Opérateur (OP) et format d’imoresssion EVAL >nil: env:degre VALUE2=5 TO=env:minpile 0P=* LFORMAT "*N" ?
EVAL >nil: env:degré VALUE2=15 TO=env:maxoile 0P=* LFORMAT
" *N" ?
EVAL >nil: env:degré VALUE2=1 TO=env:degrëplus 0P=+ LFORMAT "*N" ?
; ces trois commandes permettent de calculer un fois pour ; toute, différentes valeurs réutilisées par la suite ; il s’agit des bornes inférieures et supérieures pour la ; taille initiale de la pile (pour éviter les jeux trop ; rapides ou trop longs) et d'une variable tactique ; degréplus égalé à la taille de la poignée plus un
LAB choixpile DATE TO t:tempdate
; la fonction aléatoire repose sur les secondes : il faut avoir recours à un éditeur pour pouvoir les ; isoler correctement
EDIT FROM t:tempdate TO env:alea WITH t:commandedit ECHO "valeur aléatoire pour la oile = " NOLINE GETENV alea
IF îalea NOT GT Sminpile VAL
ECHO "Le générateur aléatoire a des rates. ATTENDEZ" WAIT 15
; si les secondes ne fournissent
; pas un nombre approprié, il faut attendre et réessayer SKIP choixpile BACK
ENDIF
IF Salea GT Smaxoile VAL
ECHO "Le générateur aléatoire a des rates. ATTENDEZ' WAIT 15
SKIP choixpile BACK ENDIF f
SETENV >nil: env:aléa pile ?
; la variable commence joue le rôle d’un balancier pour : pouvoir alterner entre les deux joueurs
; si c’est à l’ordinateur de commencer, on positionne la ; variable è la valeur H pour humain pour la prochaine ; partie et on saute â la routine de jeu de l’ordinateur IF Scommence EO "0”
SETENV commence H
ECHO “*NC'est a l’ordinateur de commencer*N"
SKIP jeuordmateur
ENDIF
IF Scommence EO "H"
ECHO "*NC’est à vous de commencer*N"
SETENV commence 0
ENDIF
LAB jeuhumain
ECHO "La taille de la pile est : " NOLINE GETENV pile
ECHO “le nombre maximum d’octets qu’on peut retirer est : NOLINE
; le paramètre NOLINE empêche le saut de ligne disgracieux ; â la fin de l’affichage GETENV degré
ECHO "Que retirez-vous de la pile ? " NOLINE SETENV >ni 1 : jeul ?
; récupération de la quantitée souhaitée par le joueur ; et vérification de sa conformité IF $ jeul NOT GT 0 VAL
ECHO "il faut retirer quelques octets sous peine de boucler ! !"
SKIP jeuhumain BACK
ENDIF
IF Sjeul GT Sdegre VAL
ECHO "Ne soyez pas si gourmand !!"
SKIP jeuhumain BACK
ENDIF
t
; Il est impossible à la commande EVAL actuelle de ! Travailler sur deux paramètres variables (comme des ; variables d’environnement), il nous faut alors ; construire le ligne complète des paramètres en ; concaténant les différentes valeurs
: Cette méthode â priori peu élégante permet de se casser
; de la création de la ligne complète de commande qu’il
; faut exécuter par un autre CLI (or, la commande EXECUTE
; qui empêche les sauts en arrière par SKIP back), elle ; est donc supérieure à toutes celles décrites dans les ; manuels
COPY env:pile t:calcul2 ECHO > >t:calcul2 " - " NOLINE GETENV >>t:calcul2 jeul
EVAL >ni 1 : t:calcul2 TO env-.pile LFORMAT "*N" ?
; séquence permettant de calculer la nouvelle valeur de la ; pile = pile - quantitèe prise par le joueur ; puis test pour savoir si la pile n’a pas pris une valeur ; nulle ou négative, c’est-ô-dire cour savoir si on a ; atteint la la fin du jeu IF $ pile NOT GT 0 VAL SETENV pile 0
SETENV vainqueur " C’est l’ordinateur qui a gagné"
EVAL >nil: env:scorî2 TO env.calcull VALUE2=1 0P=+ LFORMAT "%N" ?
COPY env:calcul1 env:score2 ; mise à jour du score de l’ordinateur à l’aide d’une : variable intermédiaire SKIP victoire
ENDIF
LAB ieuordinateur
ECHO “La pile comprend " NOLINE
GETENV pile
; ATTENTION
: c’est ici que se passe la magie de l’ordinateur ; en prenant un papier et un crayon, vous devriez pouvoir ; décrypter la tactique utilisée, mais essayez d’abord de ; construire la vôtre, cela vous aidera sûrement EVAL >nil: env:pile TO env:calcull VALUE2=1 0P=- LFORMAT "*N" ?
; calcull = pile - 1 COPY env:calcull t:calcul2 ECHO > > t:calcul2 " " NOLINE GETENV > > t:calcul2 degréplus
EVAL >nil: t:calcul2 TO env:calcul3 LFORMAT "*N" ?
; calcul3 = l pile - 1) ( degré + 1 )
COPY env:calcul3 t:calcul2 ECHO > >t:calcul2 " ** " NOLINE GETENV >>t:calcul2 degréplus
EVAL >nil: 1:calcul2 TO env:calcul3 LFORMAT "%N" ?
; calcul3 = (f degré + 1 ) * (( pile - 1) ( degré + 1 ))
COPY env:calcull t:calcul2 ECHO > > t:calcul2 " - " NOLINE GETENV >>t:calcul2 calcul3
EVAL >nil: t:calcul2 TO env:jeu2 LFORMAT ' %N ' ?
; la formule complète est donc
; jeu2 = pile - 1 - (( degré -*¦ 1 ) * (( pile - 1)
; (degré +1 )))
; savez-vous pourquoi ?
ECHO "L’ordinateur souhaiterais retirer : " NOLINE GETENV jeu2
; Pour vous aider, lorsque l’ordinateur n’a pas de bon ; coup à jouer, il le dit, et choisi une valeur au hasard ; en utilisant la encore les secondes IF $ jeu2 EQ 0 VAL
DATE TO t:tempdate
EDIT FROM t: tempdate TO env.calcull WITH t:commandedit
récupération des secondes
EVAL >nil: env:colcull TO env:calcul3 VALUE2=3 OP=mod LFORMAT "*N" ?
EVAL >nil: env:calcul3 TO env:jeu2 VALUE2=1 0P=+ LFORMAT ”*N" ? Application d’un modulo pour ramener le nombre des secondes à un chiffre compris entre 0 et 2 et addition de 1 pour le placer entre 1 et 3 ECHO “Il retire " NOLINE GETENV jeu2
ENDIF
COPY env:pile t:calcul2 ECHO > > t: caleu12 " - “ NOLINE GETENV >>t:calcul2 jeu2
EVAL >ni1 : t:calcul2 TO env:pile LFORMAT "%N“ ? Mise à jour de la pile et test de fin de partie
IF Spile NOT GT 0 VAL SETENV pile 0
SETENV vainqueur "C’est l’humain qui a gagné"
EVAL >nil: env:scorel TO envrcalcull VALUE2=1 0P=+ LFORMAT “*N" ?
COPY envrcalcull envrscorel ; mise à jour du score de l’humain SKIP victoire
ENDIF
SKIP jeuhumain BACK
; pour retourner à la boucle de jeu
LAB victoire
ECHO " *N*N*E* tl :30m*N"
GETENV vainqueur ECHO "*E‘40;31m*N*N"
un petit raffinement d’affichage avant de retourner dans la boucle principale
SKIP début BACK Nettoyage LAB fin
; il est important de nettoyer après soi
; mais on conserve les scores
DELETE t:calcul2 trtempdate t:commandedit
DELETE envrcalcull env:calcul3 envrcommence envroile
DELETE env:degré env:degréplus env:aléa env: vainqueur
DELETE pnvrminpile envrmaxpile env:jeul env:jeu2
pour libérer de la mémoire, on retire les commandes résidentes
A titre d’exercice, vous pouvez modifier le programme pour le separer en trois parties :
un programme d’installation correspondant ô la section Initialisation, avec notamment l’installation des commandes en résident
un programme de jeu pour la section Boucle principale un programme de désinstallation avec les commandes DELETE et RESIDENT .. REMOVE commandes pour nettoyer ainsi, le programme jeu qui n’aura oas â charger les commandes, ni à nettoyer, sera plus rapide RESIDENT c: if REMOVE RESIDENT c:else REMOVE RESIDENT c:endif REMOVE RESIDENT c:echo REMOVE RESIDENT c:eval REMOVE RESIDENT c:lab REMOVE RESIDENT c:skip REMOVE RESIDENT c:setenv REMOVE RESIDENT c:getenv REMOVE RESIDENT c:ask REMOVE RESIDENT c:edit REMOVE RESIDENT c: date REMOVE RESIDENT c:copy REMOVE RESIDENT c:delete REMOVE
Â,
Lvant de voir plus précisément le minitel et sa norme vidéotex voyons plutôt à quoi correspond certains termes que l’on voit de temps en temps sans vraiment les comprendre.
Les principales normes de télécommunication.
Avant l’apparition des micro-ordinateurs, les utilisateurs étaient confrontés à des problèmes d’interconnexion lorsque, voulant s’affranchir d’un constructeur particulier(par exemple pour ne pas être lié à un seule marque et être ainsi plus indépendant), ils possédaient plusieurs type de machines de constructeurs différents. Depuis quelques années, cette situation évolue rapidement grâce à la formidable croissance des « petits » constructeurs. L’ISO (International Standards Organisation) qui, comme son nom l’indique, est chargé de la normalisation des standards, a conçu le standard OSI (pour Open Systems Interconnection), standard ou plus proprement dit, architecture qui met en oeuvre une nouvelle approche du problème de l’interconnexion entre systèmes hétérogènes ; en effet, au lieu de décrire d’un seul bloc l’interface entre systèmes, l’OSI sépare le transport des informations avec celui du traitement de ces mêmes informations (en jargon encore plus technique...et oui c’est possible !... on parle de couches (en anglais : layer) : il en existe d’ailleurs sept dans cette architecture OSI : couche dite physique, de liaison, de réseau, de transport, de session, de présentation, et enfin d’application). OSI
Cette « norme des normes » des télécommunications, ne fut pas facile à mettre en oeuvre (dû surtout à la mauvaise volonté de certains constructeurs Américains... suivez mon regard...), mais maintenant elle sert de référence à la plupart des réseaux.
Je ne m’étendrai peu sur cette architecture OSI (ça deviendrait de toute façon trop technique, peut-être pour vous, sûrement pour moi !).
Je vais seulement vous dire à quoi correspondent ces « couches » :
Couche physique
Elle décrit comment l’émission d’un bit se fait et par quelles modalités (description du niveau de tension par exemple) et elle définit aussi les connecteurs employés.
La plupart des normes de cette couche existent depuis longtemps ; OSI les a heureusement gardées.
Ci-dessous, je vous livre une partie de ces normes, en ne vous donnant comme descriptif que le strict minimum :
Normes :
V21 :300 bauds.
V22 :1200 bauds et maintenant 2400 bauds. V23 :Vidéotex. 1200 bauds pour la réception et 75 bauds pour l’émission.
V24 Utilisation de signaux RS232.
V27 : 4800 bauds.
Y29 : 9600 bauds.
Ces deux dernières normes étant faites pour fonctionner uniquement sur des lignes spécialisées à quatre fils (au lieu d’utiliser le réseau téléphonique qui,lui, n’a besoin que de deux fils). Couche de liaison C’est la couche qui permet véritablement un dialogue entre deux systèmes (ou plusieurs) ; grâce à elle, la communication se fait sans perte d’information (l’émission ne peut se faire que si les autre systèmes du réseau savent qu’il va y avoir émission de la part d’un système ; d’une façon plus concise : « Fermez là, je vais parler ! » Normes :
X25 :liaison X25.
802. 2 : protocole LLC (Logical Link Control).
802. 4 : protocole Token-Bus
802. 5 : protocole Token-Ring.
Etc...
Couche de « réseau »
Elle assure la transmission des paquets d’informations en gérant leur parcours (c’est cette couche qui est par exemple responsable de la gestion des noeuds du réseau) ; en outre c’est aussi cette couche qui gère l’identification des utilisateurs du réseau.
Normes :
ISO 8208 (transmissions des paquets de type X25)
CCITT 1451 :RNIS (Réseau Numérique à Intégration de Service) plus connu maintenant sous l’appellation NUMERIS).
Couche de transport (transmission layer)
Grâce à un protocole de transport, cette couche permet l’acheminement et la reconstitution des données échangées entre deux systèmes. Normes : ISO 8073 NB : Les protocoles de transport NFS (de SUN), ATP (d’Apple), RFS (d’AT&T) ne suivent pas cette norme ISO (ces protocoles feront l’objet d’un prochain article)
Couche de session
Elle gère la mise en communication des deux systèmes.
Normes : ISO 8327
Couche de présentation et couche d’application.
Elles servent à gérer les transferts de haut niveau (par exemple elles intègrent les protocoles de transmissions de fichiers).
Normes : Pas de normes vraiment définies.
Le minitel.
Son modem fonctionne seulement en mode V23(donc 1200 bauds en réception et 75 en émission) et il est retournable, possibilité facilement exploitable en théorie car il suffit d’envoyer deux caractères pour le faire, mais plus difficile à mettre en pratique).
France Télécom a livré plusieurs modèles de minitel :
Minitel 1 avec clavier disposé en ordre alphabétique (une véritable horreur !).
Minitel 1 avec clavier azerty.
Minitel 1B qui possède en plus de la norme vidéotex (40 colonnes, caractères spéciaux) la possibilité de mettre son écran en 80 colonnes, avec les caractères ASCII),
Minitel 10 qui est un minitel 1B standard mais qui, premièrement peut stocker 10 numéros de téléphone et deuxièmement peut composer ces numéros ; plutôt réservé aux plus fortunés car contrairement aux autres dont la location est gratuite, le minitel 10, qui est un minitel 1B standard mais qui, premièrement peut stocker 10 numéros de téléphone et deuxièmement peut composer ces numéros.
Si vous possédez un minitel de type 1, je vous conseille de l’échanger contre deux barils...ops...un minitel 1B (dans toutes les bonnes agences des Télécom), car ainsi vous pouvez non seulement vous brancher sur les services minitels comme COMREV (heureusement d’ailleurs !) Mais aussi sur les serveurs plus sophistiqués se servant d’un système d’exploitation standard (MSDOS, UNIX, AMIGA- DOS..).
Liaison Minitel-Amiga
Bien que le minitel soit un véritable terminal télématique, son usage est limité à la visualisation sans qu’il y ait possibilité de sauvegarde sur support magnétique ; c’est une des raisons pour relier son ordinateur au minitel ; mais il y a d’autres arguments pour faire ce branchement : le téléchargement, la couleur, le clavier de l’Amiga bien plus agréable que celui du minitel et grâce à l’Amigados, la possibilité d’avoir une fenêtre (ou un écran) de télécomunication tout en travaillant sur tout autre chose (en ce moment, je tape ce texte sur Amiga tout en ayant un système UNIX dans un écran d’« Atalk »). Les émulateurs minitel sur Amiga.
Il vous faudra attendre le prochain numéro pour avoir une description complète de ces logiciels (et aussi pour avoir un schéma de branchement valable sur Amiga).
16 millions de couleurs sur l’Amiga
Au cas où vous seriez lassés des 4096 couleurs de votre écran, il existe des possibilités de sortie jusqu’à 16 777 216 couleurs, et même plus, à partir d’un Amiga standard. Oui, vous avez bien lu, 16 millions de couleurs et dans des résolutions qui vont jusq’a 4000x3000.
Un des logiciels qui permet ce genre d’exploit est bien connu et se nomme SCULPT 4D. Voici comment procéder : vous avez créez une magnifique scène avec SCULPT et vous voudriez la sortir sur photo pour épater les copains. Une photo d’écran est souvent décevante, alors pourquoi ne pas shooter votre image en 24 bit- planes. Sélectionnez la rubrique OBSERVER MODE BIT PLANES. Dans la cellule qui apparaît effacez le 6 et entrez 24. Aussitôt une autre cellule s’ouvre, demandant le nom du fichier RED. Vous allez créer une image au format RVB (ou RGB en anglais), soit un fichier pour le rouge, un pour le vert et un pour le bleu. Dans un fichier RVB, les données sont stockées sous la forme de 8 bits par pixel pour chacune des couleurs. La structure des fichiers est simple, puisqu’elle ne contient que les informations propres aux pixels sans « header ». Une bonne résolution serait de 1024x683, qui occupe 699 392 octets et tient juste sur une disquette. Après avoir entré la dimension de votre image vous allez lancer le calcul. Là, il vaut mieux avoir une carte accélératrice, car un calcul qui met 10 heures en résolution 320x256, mettra huit fois plus de temps en 1024x683. La carte A2630 de Commodore, qui contient un 68030 à 25Mhz, accélère 14 fois le calcul et sera la bienvenue pour ce genre d’application.
Vous avez maintenant sorti vos fichiers sur disquette. Il ne vous reste plus qu’à trouver une société pour les traiter. Actuellement deux sociétés en France offrent ce type de service sur des fichiers provenant d’un Amiga :
Ces sociétés utilisent des MATRIX 3000 PCR pouvant traiter des résolutions jusqu’a 4096x2732. Le temps de développement est d’1 2 heure et les sorties se font sur 24x36 où 4x5 inch. Il vous en coûtera entre 100 et 400 F, mais les résultats sont réellement impressionnants.
Autre logiciel permettant de créer des fichiers RVB en 24 Bit Planes ; ProScanLab le logiciel d’ASDG permet de piloter le scanner SHARP JX 300 (16 millions de couleurs, 300 points par pouce). Avec ce logiciel, vous pouvez sauvegarder vos fichiers image, soit au format IFF, soit au format RVB. Il n’est pas forcément intéressant de scanner une photo couleur, pour ensuite la ressortir sur papier photo. D’où l’intérêt de la nouvelle version de Professional Page, qui vous permettra d’inclure dans vos fichiers postscript, une image RGB 24 bit-planes en lieu et place d’une image IFF. Vous chargerez normalement une image IFF dans votre page, puis au moment de la sortie postscript, vous remplacerez le fichier de cette image par un fichier RVB.
Evidemment pour apprécier le résultat, il faut effectuer la sortie en séparation de couleurs. Une fois que vous avez vos quatre fichiers quadrichromie, il faut, là aussi, trouver une société pour les traiter. Les imprimeurs acceptant les fichiers Postcript, sont nombreux, mais malheureusement, demandent généralement des disquettes au format PC. Pour transférer vos fichiers Postscript, la meilleure solution est une carte passerelle XT (A2088) ou AT (A2286) et l’utilisation de la commande Aread sous MS- Dos. Une fois les fichiers transcrits sur disquette PC, votre imprimeur sortira les quatre films nécessaires à la photocomposition.
Voilà donc quelques solutions qui vous permettront de faire de belles sorties papier, à partir de l’Amiga. Alors, graphistes et journalistes à vos disquettes...
ZARMA PHONG
ABAQUE MICRO
et
EUROGRAPH
23 Rue du Poteau
12 Rue des Brosses
75018 PARIS
25000 BESANCON
Tél : 46 06 88 80
tél : 81 80 69 09
LA TUBEINTRO DE LITTLE ZEUS
Et nous revoici ensemble pour entamer le plat de résistance : le scrolling multiparamétrable et multi- directionnel. Celui-ci vous est offert par le meilleur restaurant de la galaxie informatique: Commodore-Revue.
Le mois dernier, vous avez certainement été très fiers de voir aboutir fructueusement le travail de plusieurs mois et d’obtenir à l’écran votre logo, enfin complètement animé.
Nous achèverons le scrolling seulement dans deux numéros, ceci à cause de sa longueur et de sa légère complexité. Celà ne veut pas pour autant dire que nous allons voyager à travers le Copper, le Blitter et les Plafields... d’ailleurs, nous nous servons dès aujourd’hui du scrolling pour illustrer un processus méconnu mais qui, dès qu’il est révélé au grand jour (ce qui est fait un peu plus bas) apparaît tellement utile qu’il en devient indispensable. Cessons de vous mettre l’eau à la bouche. Nous nous intéressons cette fois-ci à la possibilité de changer le mode de Playfield à n’importe quel emplacement de l’écran ; effectivement, après avoir utilisé un Single-Playfield de trois Bitplanes pour l’animation de notre logo, dont je ne doute pas que vous avez admiré avec plaisir la danse céleste, nous utilisons un Dual-Playfield et quatre bitplanes pour le scrolling. Tout ceci nous est possible grâce à un co-processeur, unique apanage des Amiga, le COPPER.
Figure 2 illustre ceci : un paysage a été dessiné sur une image et, un mur de maison avec, en son milieu, une fenêtre sur une autre. A présent, nous désirons voir le paysage à travers la fenêtre : il suffit de superposer les deux images en ayant pris préalablement le soin de remplir la fenêtre de la couleur transparente (fig. 3). Mais attention ! Pourquoi ne serait-ce pas le paysage qui serait placé à l’avant du mur? Parce qu’il existe un registre qui donne, suivant sa valeur, la priorité du mur sur le paysage ou inversement. Mais alors pourquoi utiliser le mode Dual- Playfield si on peut avoir exactement le même effet à l’écran, en ayant seulement dessiné une seule image ? Et bien parce que le mode Dual- Playfield devient intéressant si nous remplaçons notre fenêtre de maison par un hublot d’avion et si nous faisons scroller le paysage ; nous avons alors, en faisant scroller l’image de derrière de droite à gauche, ou même de bas en haut, le sentiment d’être dans un avion en mouvement. N’est-ce pas merveilleux ? Cependant le mode Dual-Playfield a un défaut : il permet au maximum huit couleurs par Playfield, car l’Amiga offre uniquement six bitplanes. En utilisant tous les Bitplanes pairs pour un Playfield
Le procédé est très simple pour ne pas dire évident : au moyen du Copper nous attendons une ligne ; au moment où celle-ci est atteinte, il suffit de modifier le registre relatif aux Play- fields et à partir de cette ligne l’écran passe en mode Dual-Playfield !
Avant d’expliquer la nécessité de ce mode au sein du programme, attardons-nous sur son fonctionnement. Il s’agit d’avoir deux écrans pour le prix d’un ! Explication un peu laconique, n’est-ce pas ? Imaginez que vous ayiez deux images (fig. 1) ; dans chacune d’entre elles, la première couleur correspond au transparent, c’est-à-dire que lors de leur superposition, l’image avant laissera apercevoir l’image arrière à travers la première couleur de sa palette. La
et les Bitplanes impairs pour l’autre, ce qui fait trois Bitplanes par Playfield, le chiffre maximal est % 111 =8. Dans notre intro nous n’aurons besoin que de deux Biplanes par Playfield, la Charset utilisant seulement quatre couleurs. Nous aurons néanmoins beaucoup plus de quatre couleurs pour le scrolling car nous utiliserons le Cooper pour en rajouter et surtout pour renforcer l’effet de courbure du tube.
Après la théorie, la pratique. D’abord une présentation des différents mouvements possibles du Scrolltext : celui-ci peut monter et descendre ; il peut rouler vers le haut et vers le bas (scrolling de rotation vertical) ; et bien sûr, il est animé d’un mouvement horizontal, de la droite vers la gauche. Les combinaisons de ces différents mouvements engendrent des effets que vous découvrirez, ébahis, dans deux numéros. Descendons maintenant dans les coulisses de l’écran ptnjr comprendre par quel moyen miraculeux nous animons le scrolltext de la sorte. Les mouvements verticaux de rotation sont exécutés à l’aide de Scrollraster, routine de la Graphics. Library qui permet les scrollings dans le
sens désiré, à l’intérieur d’un parallélogramme. Il en est de même pour le scrolling horizontal.
Quant au scrolling vertical, nous usons d’un subterfuge ; nous aimons celà. Nous allons avoir recours à une méthode que nous avions déjà quelque peu vue le mois dernier : le repointage des Biplanes. De la même manière que dans le numéro précédent nous repointions les Bitplanes pour créer l’effet de déformation, nous allons ici les repointer pour donner une impression de scrolling vertical (à ne pas confondre avec le scrolling vertical de rotation). Ne paniquez pas si ceci vous apparaît quelque peu confus, nous allons nous appuyer sur un exemple : lorsque vous avez la fenêtre du Workbench à l’écran et qu’au moyen de la souris vous faites descendre le cadre, vous avez un scrolling vertical, mais celui-ci est uniquement illusoire.
Imaginons que nous fassions descendre le cadre de X pixels, alors le système d’exploitation se charge de poker la valeur de base des Bitplanes dans les registres correspondants, au moment ou le Raster atteint cette ligne X. Mais comme dans notre programme, nous devons repointer les Bitplanes (à cause des effets couleurs sur le tube) après avoir dépassé la position réelle du scrolling ; nous devrions avoir deux scrollings simultanément à l’écran ; nous éliminons donc cet effet indésirable en mettant à 0 les couleurs, lorsque le Raster balaye la partie de l’écran correspondant à l’emplacement réel du scrolling. Vous remarquerez que j’utilise le mode « un Bitplane », et ce, afin d’avoir uniquement une seule couleur à mettre à 0.
Il s’agit maintenant de faire tourner notre tube : notre cylindre est divisé longitudinalement de manière à ce que la partie avant du cylindre appartienne au Playfield avant et la partie arrière, au Playfield arrière (ce n’est pas très original). Nous animons donc les demi-cylindres avant et arrière du scrolling, de deux mouvements opposés à l’aide de Scrollraster. Cependant, celà ne suffit pas pour avoir notre scrolling en rotation autour du tube, car il manque la copie des lignes extrêmes d’un Playfield à l’autre. Soyons un peu plus explicites : si vous désirez voir réapparaître à l’arrière la ligne supérieure (en admettant que le cylindre tourne vers le haut) de votre message de la partie avant du cylindre, il faut le recopier ligne par ligne. Pour ne pas avoir de parasites à la ligne où nous copions d’un Playfield à l’autre, nous mettons les couleurs à 0. Mais attention, selon le sens de rotation du tube, les copies se feront du Playfield avant vers l’arrière, ou Inversement. Par exemple, si le tube prend un sens de rotation vers le haut, la partie avant du haut du tube subira une copie du Playfield avant, vers le Playfield arrière. Le bas du tube subira le sort contraire (fig. 4).
En ce qui concerne l’effet des couleurs sur le tube, nous l’expliquerons clairement le mois prochain. Si dans la routine, vous vous êtes étonnés de voir que le Playfield avant est décalé de 16 pixels vers la droite, sachez que celà concerne la forme du tube et nous en verrons l’explication la fois prochaine.
N’essayez pas d’assembler la routine puisqu’elle est encore incomplète et donc inexécutable. Ne soyez pas pris de court le jour où nous publierons la dernière partie de la routine du scrolling. Préparez une police de caractères de 40 pixels de largeur sur 32 de hauteur ? Pernière chose, cette fois-ci, nous avons vu le principe de fonctionnement du scrolling un peu grossièrement ; dans le prochain numéro, nous reviendrons sur des parties de routines publiées ici, en les éclairant.
Sur ce, je vous quitte et vous donne rendez- vous dans le prochain numéro pour la suite de la Tube-intro. Je vous rappelle que toutes vos suggestions, critiques ou questions sont les bienvenues.
Little Zeus
;--*Tuhe-lntro de Little Zeus: Phase?.1ere partie(inexécutable)*--
;-------------copper list (suite)---------------------
dc. w S9b09,*fffe.$ e2,S6bdO ; pointe zone vide pour effacer la partie réelle du scrolline
dc. w *100,51200 « autorise 1 bitplnne
mil: dc.w S9d09.Sfffe.*100,*4200 -.active 2 playfields de deux bitplanes chacun
dc. w te?.*1226 : pointe sur partie mémoire scrolline de.w tea.*5aOS
dc. w Se6.S3616
dc. w *ee,*7df6
dc. w *182.*00,*184,0,*186,0,*192,0,*194,0,*196,0 ; couleurs noires
ml2: dc.w *9e09,*fffe
dc. w *182,S004.S184.Sfff.*186.*444.*192,*456,*194.*789,*196.*234
- , couleurs utilisées pour notre scrolline
coco: blk.b 32*12 : réservation de mémoire pour les effets couleurs et pour la forme du tube(è voir prochainement) ml3: dc.w *Be09,*fffe
dc. w *100,*1200 : nous nous mettons en mode 1 bitplone avec Couleur et nous pokons sa seule couleur h 0
DC. W *182,0 ; pour éliminer les parasites
mel*46*102 iadresse de base de la lere liene du scrolline me2*4,6*133 (idem pour la dernière liene
hautl * bltmel+2 ;adresse de base de la partie avant du scrolline au sein du bitplane 1
haut2 ¦ b3*mel*2 i idem pour le bitplane 3
haut21 = b2'melj idem pour la partie arrière du scrolline
haut22 = b4*mel 4
basl * bl‘me2»2 i nous refaisons exactement la même chose pour les addresses de base de la dernière liene du scrolline bas2 = b3*me2*2 bas21 • b2*me2 bas22 * b4?me?
Piedata: dc.î cara **98 : adresse de base des données IFF de notre alphabet
f (rajouter isr rout dans la boucle souris
move.l gfxbase.aS isr avant ; remet a 1our
1sr scrollhor ; routine des scrollings horizontaux et verticaux de rotation rts
:------- effets couleurs sur scrolline---------------
jroutine semblable à celle des effets couleur sur le lopo ccol:
move.l ccolor.dO
move.l drc.dl ; dre correspond à la direction du scrolline de rotation, 1 pour la montée et -1 pour la descente add.1 dl.dO -.pointe sur la prochaine couleur add.l dl.dO move.l dO.ccolor
move.w culie,d4 iliepe initiale du scrolline è mettre dans copper list
lea coco,al move.l 31,d3 move.l ccolor.dl cmp.l 4>chcolf,dl bne.L bcb2
move.l echcol.ccolor bra bcb3
bcb2:
cmp.l *cheol-2,dl : bne bcb3
move.l chcolf-2,ccolor bcb3:
move.l ccolor.aO boucle:
move.w d4.(al ) add.l 4>8,al move.w **182,(al)* move.w (aO)*,(al>* add.l »*100,d4 cmp.l chcolf,aO
bne boucle2 1ea chcol,aO boucle2: dbra d3,boucle
îïlty2: SUITE EN PAGE 51
suite de la page 42
;------------scrolline vertical de rotation------------------
scrup:
cmp.b 0swt nécessaire pour une option du scrolline, expliqué dans un prochain numéro bne coo »
cmp.l 0,drc ; s’il n’y a pas de scrolling vertical, inutile de faire des copies beq coo
isr trans ; copie débordement haut jsr anum2 j copie débordement bas coo:
isr pfl Sélectionne olavfield avant pour scrollraster move.l drc.dl ; met direction du scrolling en dl isr scrold rts
move.1 gf xbase,a6
scrold:
clr.l dO
clr.l d2
move.1 101,d3
move.l 320,d4
move.l 134,d5
lea rastport,al
isr scrollraster(a6 )
rts
• ---------routine de copie d’un playfield à l’autre-----------
trans:
cmp.l l,drc » bne adrc2 ;
; routine appelée quand le scrolling monte et copie de la ligne extrême du haut du playfield avant sur l’arrière move.l hautl,a0 > move.l haut2,al » move.l haut21-46,a3
move.l haut22-46,a4 bra suite »
; routine appelée quand le scrolline: descend et copie de la ligne extrême du haut du playfield arrière sur l’avant adrc2:
move.l hautl-46,a3 move.l haut2-46,a4 move.1 haut21.aO move.l haut22,al bra suite
drc direction du playfield avant ;drc2 direction du playfield arrière ; routine anum2:
cmp.l 1,drc2 bne bdrc2 ;
; routine appelée quand le scrolline monte copie de la ligne extrême du bas du playfield arrière sur celui de devant
move.l basl,aO ; monte copy avant sur arrir ere en bas
move.1 bas2,al
move.l bas21+46,a3
move.l bas22+46,a4
bra suite î fait copie
* , routine appelée quand le scrolline descend, copie de la ligne extrême du bas du playfield arrière sur celui de devant bdrc2:
move.l basl+46,a3 move.l bas2 + 46,a4 __
move.l bas21,a0 move.1 bas22,al suite:
move.l 18,d3 ; copie 38 octets
bobo : . '
move.l (a0),(a3)+ *'
move.1 (al),Ca4 > +
add.l 4,aO
add.l 4,al
dbra d3,bobo
rts
(PETITE) INITIATION AU GFA-BASIC
lors, il avance, ce jeu ? Ah, vous avez encore quelques problèmes... Qu’à cela ne tienne, cette troisième et dernière partie de notre (petite) initiation au GfA-Basic devrait vous aider à y voir plus clair...
J’en devine certains, au fond de la classe, qui se demandent à quel jeu je peux bien faire allusion. Alors pour les attardés et ou les petits nouveaux, je rappelle que Micro-Application et Commodore Revue (c’est nous !) Ont lancé, à l’occasion du GfA-Basic sur Amiga, un petit concours doté de prix sympathiques. Le but est de réaliser, entièrement en GfA, un petit jeu quelconque, exploitant les capacités tant de l’Amiga que du GfA-Basic. Pour vous aider, et compte tenu de la nouveauté de ce langage, nous publions depuis maintenant trois mois une miniinitiation au GfA, destinée à vous aider à mettre vos idées en forme. Non, non, ne nous remerciez pas, c’est tout naturel, voyons.
Si ma mémoire est bonne, vous avions vu en détail toutes les instructions graphiques que le GfA-Basic possède : dessins géométriques quelconques, mais également sprites, bobs, etc. Mais, vous vous en doutez certainement, ce n’est encore pas suffisant. Il va falloir maintenant nous intéresser de plus près à l’organisation de l’écran au sens large du terme pour pouvoir le bidouiller quelque peu.
LE VIEWPORT
Sans trop vouloir entrer dans les détails, le « viewport« n’est rien d’autre que le coeur de tout écran Intuition : il s’agit d’une structure de 40 octets, dans laquelle on trouve les différentes particularités de l’écran correspondant (mode, couleurs, etc.). Ce viewport va nous servir dans notre jeu, car Intuition possède plusieurs fonctions qui lui sont consacrées, la plus intéressante pour nous, étant bien entendu le scrolling.
Pour obtenir l’adresse du viewport de notre écran, il suffit d’employer la fonction SCREEN(x), où x est le numéro de l’écran dont on recherche le viewport. Par exemple :
OPENS 1 ' c*
viewport%=SCREEN(1)+44
et la variable viewport% contiendra l’adresse du viewport de notre écran.
Qu’allons-nous donc en faire ? Je vous rappelle que GfA-Basic met à notre disposition toutes les fonctions des bibliothèques Intuition les plus utilisées, sans passer par des « Library« sans fin, comme c’était nécessaire en AmigaBasic. Dans le cas présent qui nous préoccupe, les fonctions
de !a « Graphics.library* vont nous êtres utiles. Et je le prouve, sans plus tarder :
Void ScrollVPort(vport%,de!atx&,de!aty&) où vport% est donc l’adresse de la structure ViewPort de notre écran, deltax& et de!tay& les valeurs horizontales et verticales (respectivement) du scrolling, exprimées en pixels. Ainsi, le programme suivant :
OPENS 1,0,0,320.256,3 voort%=SCREEN(1 ;+44 PCIRCLE 160,128,100 FOR scrolletir«=0 TO 319 ~SCROLLVPORT(vport%,1,0) NEXT scrolle,ur&
~ASC(INPUTS ( 1 ) )
CLOSES 1 EDIT
commence par ouvrir un écran, puis dessine un cercle rempli en
son centre, pour enfin décaler cet écran (de manière assez fluide
il faut le reconnaître) jusqu’à disparition dudit cercle. L’effet
peut être amélioré en ajoutant dans la boucle l’instruction
VSYNC, qui attend le retour du rayon de balayage du moniteur.
Comme vous le voyez, cela ne présente aucune difficulté (enfin, si, une quand même, comme nous Talions voir au prochain
paragraphe) insurmontable. Libre à vous maintenant de compléter
l’image au fur et à mesure du scrolling, afin de donner un effet de travelling.
Oui, j’évoquais plus haut, au sein des parenthèses, une
difficulté à surmonter : en cas d’utilisation de bobs (et celà m’étonnerait beaucoup que vous n’en fassiez pas usage), il vous faudra attendre le moment précis où ils seront tous effacés de l’écran pour scroiler celui-ci, sinon des effets secondaires... heu... disons inesthétiques risquent d’apparaître. Cela implique donc un timing très fin et aucune perte de temps dans le programme. A moins d’utiliser une technique particulière connue sous le nom de...
fait qu’une zone de mémoire servant de buffer et dans laquelle on dessinera toute l’image, avant de l’afficher sur le moniteur. Le premier écran deviendra à ce moment-là le buffer, dans lequel on dessinera la prochaine image devant apparaître, et ainsi de suite.
La difficulté consiste ici en l’ouverture des deux écrans, ainsi qu’en l’affichage sur le moniteur de celui « caché« en mémoire. Bien sûr, un programme du genre :
OPENS 1,0,0,320,256,3 OPENS 2,0,0,320,256,3 DO
FRONTS 1 ! Ecran 1 sur le 2 ’ On dessine dans l’écran 2 FRONTS 2 ! Ecran 2 snr le 1 ’ On dessine dans l’écran 1 LOOP
simplifierait la tâche, mais vous pouvez essayer l’effet ne
rend pas très bien. Malgré le fait que les deux écrans aient les
mêmes dimensions et la même palette (c’est obligatoire !) La transition entre les deux reste visible. D’où la seconde méthode, qui bien sûr, élimine ce problème et présente en plus, l’avantage de consommer (un peu) moins de mémoire.
Pour la mettre en oeuvre, il convient de programmar le COPPER, ce co-processeur qui pilote tous les processeurs spécialisés de l’Amiga. Pas directement rassurez-vous, nous allons utiliser les fonctions Intuition prévues à cet effet.
Les procédures suivantes résoudront le problème de la mise en place du « double buffering” , de l’échange des deux écrans, ainsi que du retour à la situation normale :
3615
COMREV
I
VOTRE SERVEUR SUR AMIGA !
DOUBLE BUFFERING
En consisté-ce ? L’idée de base est très simple à comprendre : il s’agit d’utiliser, non pas un écran mais deux, dont un seul sera bien sûr visible sur le moniteur. Le second écran ne sera en
Suite au prochain numéro.
L’assembleur 68000 nMO
Snitialiser un menu est une chose assez harassante à mettre en oeuvre. Non pas que cela pose des difficultés particulières, mais il faut y passer un certain temps, pour ne pas dire un temps certain. Nous allons voir maintenant qu’une structure Menu complète prend beaucoup de place dans un listing.
Une structure Menu est donc composée de 28 octets :
Offset
Signification
0
Prochain Menu
4
Position X
6
Position Y
8
Largeur
10
Hauteur
12
MenuFlag
14
Pointeur sur le texte
18
Pointeur sur le 1er point
20
4 mots réservés au système
Le premier mot long est l’adresse de la prochaine structure Menu, dans la barre de menus. Le nombre de structures possibles n’est limité que par la largeur de l’écran. Si aucun autre menu ne suit, ce mot doit être mis à zéro.
Les quatre mots suivants (position et dimension) ne devraient poser aucun problème, si l’on se rappelle que les valeurs sont exprimées en pixels.
Le mot intitulé « MenuFlag » ne peut prendre que deux valeurs. Il indique si le menu en question peut être déroulé (MenuFlag = 1) ou non (MenuFlag = 0). Un menu non sélectionnable se reconnaît au fait que toutes ses entrées apparaissent en grisé.
Le mot long suivant est l’adresse du texte- titre de notre menu.
On trouve ensuite un autre mot long, qui est un pointeur sur la structure du premier point de notre menu (un point de menu n’étant rien d’autre que l’une des options sélectionnâmes dans le-dit menu).
Quatre mots viennent enfin conclure cette structure, qui sont réservés pour Intuition.
Mais tout cela ne suffit bien entendu pas. En plus des titres de menus eux-mêmes (nous grouperons tous les textes en fin de listing), il faut définir leurs différentes entrées. Là encore, des structures particulières sont à initialiser. Nous appelerons cette structure MenuPoint, qui ne
devra bien sûr pas être confondue avec la structure Menu évoquée ci-dessus. Cette structure MenuPoint est définie de la manière suivante :
Offset
Signification
0
Prochain point de menu
4
Position X
6
Position Y
8
Largeur
10
Hauteur
12
MenuPointFlags
14
Exclude
18
Pointeur sur le texte
22
Pointeur HIGHIMAGE
26
ShortCut
28
Pointeur sur le sous-menu
32
1 mot long réservé
Détaillons maintenant cette structure.
Le premier mot long est un pointeur sur la structure du prochain point dans le menu. Si le point de menu actuel est le dernier, il doit être mis à 0.
On trouve encore une fois une indication de la position de notre point de menu, par rapport à la boîte entourant tous les points du menu et exprimée en pixels.
Le mot « MenuPointFlags » permet de définir les particularités de notre point de menu. Chaque bit a une signification particulière :
Bit
Nom
Signification
0
CHECKIT
Le point sera crocheté
s'il est sélectionné
1
ITEMTEXT
Le point de menu est du texte
2
C0MMSEQ
La sélection est également
possible avec Amiga +Touche
3
MENUTOGGLE
Crochet activé puis enlevé
4
ITEMENABLED
Point du menu sélectionnable
6
HIGHC0MP
Point inversé si sélectionné
7
HIGHB0X
Point encadré si sélectionné
8
CHECKED
Point déjà crocheté
Intuition offre la possibilité de désélectionner un point de menu particulier, lors de la sélection d’un autre point de menu. Le mot long qui suit est donc un pointeur sur le point de menu à dé-sélectionner dans ce cas, ou bien 0 si aucune exclusion ne doit avoir lieu.
On trouve ensuite un pointeur sur le texte, qui composera ce point de menu.
Il est également possible, lors de la sélection du point de menu, de remplacer son texte par un autre texte, ou bien par un dessin. Le mot long suivant est un pointeur sur le texte, ou le dessin de remplacement.
L’octet suivant contient le code ASCII de la touche qui, combinée avec la touche Amiga- droite, permettra d’appeler le point de menu, sans dérouler le menu lui-même (on appelle cela un raccourci clavier). Il est suivi d’un octet de remplissage, afin que l’adresse suivante soit paire.
Vient ensuite un mot long pointant sur le sous-menu qui se déroulera par la sélection de ce point. Si aucun sous-menu ne doit apparaître, ce pointeur doit être nul.
Et pour terminer, on trouve un mot long qu’intuition utilisera de manière transparente au programme.
Tous les points de menu sont bâtis d’après cette structure MenuPoint. Les différents points d’un sous-menu sont, eux aussi, bâtis d’après cette structure.
Il nous reste toutefois une dernière structure à étudier, la structure IntuiText. Tous les textes présents dans un menu, à l’exception du titre des menus eux-mêmes, sont bâtis d’après une structure IntuiText. En effet, je vous rappelle qu’un point de menu n’est rien d’autre qu’une « boîte », dans laquelle viendra s’inscrire un texte particulier. La structure IntuiText ne fait que 16 octets et est conçue comme suit :
Offset
Signification
0
Détail Pen
1
Block Pen
2
Write Mode
4
Position X
6
Position Y
10
Fonte à utiliser
14
Pointeur sur le texte
18
Pointeur sur le prochain texte
Nous avons déjà vu, à l’occasion des structures NewScreen et NewWindow, la signification de Détail Pen, Block Pen et Fonte.
La position est là encore exprimée en pixels et par rapport au coin supérieur gauche de la boîte contenant le texte, autrement dit, le point de menu.
Nous trouvons ensuite un mot long, pointeur sur le texte lui-même.
Une structure IntuiText étant également obligatoire pour, par exemple, les requesters, il est possible qu’il y ait plusieurs lignes de textes à afficher, d’où la présence du dernier mot long.
Toutefois, dans le cas de menu, il est évident qu’une seule ligne de texte devra apparaître ; ce pointeur sera donc fixé sur 0.
BEN DIS DONC !
Voilà qui clôt notre étude des différentes structures associées à un menu. Pour illustrer tout cela, nous allons mettre en place une barre de menus qui comportera deux titres (“Titrel” et “Titre2”). Le premier titre comportera trois
points (“Pointl 1” à “Pointl 3”), tandis que
le second en comportera cinq (“Pointl 1” à
“Pointl 5”). Le troisième point de ce second
titre provoquera l’apparition d’un sous-menu, comportant lui-même deux points
(“Point2 3 1” et “Point2 3 2”). En voici une
représentation « graphique » :
Menul Menu2
ùPoint 1.1 ùPoint 2_1
ùPoint 1 2 ÙPoint 2_2
ùPoint 1_3 ùPoint 2_3--ùPoint
2 3 1
ùPoint 2_4 ùPoint
2 3 2
ÙPoint 2_5
Étudiez donc ce menu eî, en vous aidant des routines de mise en place et de fermeture d’un menu, amusez-vous à le modifier à votre guise pour le mieux comprendre ; je suis conscient que les explications que j’ai pu vous donner ici ne soient pas forcément très claires dès le premier abord. N’oubliez pas que c’est en se mouchant que l’on devient moucheron...
Max
; Zone de données du menu
; Préparez vos doigts, y'a ô taoer !
MenuDefs:
; Premier titre
Menul:
do.l Menu2
prochain titre de menu
dc. u 8,0.50,12
X, Y, L et H
dc. u 1
MenuFlao
de.1 MenulName
Pointeur sur le texte
dc. l Menul_l
Pointeur sur le 1er point
dc. u 0.0.0.0
i. mots réservés
: Deuxième titre
Menu2:
de. 1 0
Pas d'autre titre
dc. w 58.0,50.12.1
de. 1 Menu2Name. Menu2
.1
dc. w 0.0.0.0
: Premier point du premier titre
Menul_l:
de.1 Menul_2
Prochain point de menu
dc. w 0,0.130,12
X. Y. L et H
dc. u *10011111
MenuPointFlaos
de. 1 0
Exclude
de. 1 Menul_lText
Pointeur sur le texte
de. 1 0
Highlmage
dc. b 0.0
Pas de ’shortcut’
de. 1 0
Pas de sous-menu
dc. l 0
1 mot long réservé
; Second Point du premier titre
dc. l Menul_3
dc. u 0,12,130.12,S4F
dc. l 0.Menul_2Text,0
dc. b 0,0
dc. l 0,0
; Troisième
(et dernier) point au premier titre
Menul_3:-
ce. 1
0
GC . W
0. 24,130,12,S4F
«30. 1
0, P1enul_3Text, 0
oc.b
0. 0
30. 1
0. 0
; Premier point Ou second titre
Menu2_l :
«30. 1
Menu2_2
30. W
0,0,130,12,$ 9F
OC. 1
0,Menu2_lText,0
dc. o
'A’,0 ; SnortCut : Amiga-rA
oo. 1
O
O
; Second po:
nt au second titre
Menu2_2:
oc. 1
Menu2_3
oc. W
0,12,130,12,$ 57
oc. 1
0,Menu2_2Te x t,0
dc. o
’B’ .0
oc. 1
O
o
; Troisième
point Ou secono titre (appelle un sous-menu)
Menu2_3:
de. 1
Menu2_4
oc. W
0,24,130,12,$ 92
oc. 1
0, Menu2_3Text,0
oc.b
0,0
oc. 1
Menu2_3_l ; Pointeur sur le sous-menu
oc. 1
0
; Quatrième
point du secono titre
Menu2_4:
oc. 1
Menu2_5
oc. W
0,36,130,12,$ 52
oc. 1
Û.Menu2_4Text,0
oc. B
0. 0
oc. 1
0. 0
; Cinouième
(et aernier) point au second titre
Menu2_5:
oc. 1
0
Oc. W
0,48,130,12,$ 52
Oc. 1
0,Menu2_5Text,0
Oc. B
0,0
OC. 1
0,0
; Premier point ou sous-menu Ou troisième' point Ou
secono titre
rienu2_3_l :
dç. 1
Menu2_3_2
Oc. W
0,0,130,12,$ 52
oc. 1
0, Plenu2_3_lText, O
oc. B
0. 0
oc. 1
G, 0
; Second point ou sous-menu ou...
r. enu2_3_2:
oc. 1
0
OC. W
0,12,130.12,S9F
oc. 1
0, f1enu2_3_2Text, 0
oc. B
’S’ ,0
oc. 1
O
O
; Les différents textes devant apparaître oans ies
titres et
; les points
sont groupes ici.
; O’aborO, les titres aes
deux menus
ttenulName:
oc.b
even
* Menu!*,0
Menu2Name:
Oc. B even
’Menu2’,0
; Et maintenant.
Les structures IntuiText de tous les points
Menul_lText:
Oc. B
1 ; Détail Pen
oc. B
0 ; Biock Pen
remplissage
oc. B
0,0 ; WriteMooe et
Oc. W
5,2 ; X, Y
oc. 1
Menul_lTxt ; Aoresse Ou texte
Menul_lT xt:
oc. B even
* Point 1_1*,0
Menul_2Text:
oc. B
1,0,0,0
oc. W
5,2
oc. 1
f"5enul_2Txt
Menul_2Txt:
oc. B even
'Point 1_2*,G
Menul_3Text:
oc. B
1,0.0,0
oc. W
5,2
oc. 1
Menul_3Txt
Menul_3Txt:
oc.b
even
' Point 1_3’ , 0
Menu2_lText:
oc.b
1,0,0,0
OC. W
5. 2
oc. 1
Menu2_lTxt
Menu2_lTxt:
Oc. B even
'Point 2_1*,0
Menu2_2Te*t:
oc. B
1,0,0,0
oc. W
5,2
oc. 1
rienu2_2T xt
Menu2_2T xt:
oc. B even
’Point 2_£’,0
Plenu2_3Text :
oc.b
1,0,0,0
oc. W
5,2
oc. 1
P1enu2_3Txt
Menu2_3T xt:
oc. B
'Point 2_3’,0
Plenu2_4Text :
oc. B
O
o
o
«H
oc. W
5,2
oc. 1
Menu2_4T x t
Menu2_4Txt:
oc. B even
'Point 2_4',0
Menu2_5Text:
oc. B
O
O
O
•H
oc. W
5,2
oc. 1
Menu2_5T xt
Menu2_5Txt:
oc. B even
'Point 2_5’,0
; Et pour finir.
Les aeux
structure IntuiText Oe notre sous-menu
Menu2_3_l Te x t :
Oc.b
1,0,0,0
oc. W
5. 2
Oc. 1
Menu2_3_lTxt
ttcnu2_3_lTxt:
oc.b
even
' Point 2_3_1 ’ , 0
Menu2_3_2Text :
oc. B
1,0,0,0
oc. W
5,2
oc. 1
Menu2_3_2T xt
Menu2_3_2T xt:
oc. B even
'Point 2_3_2* ,0
L
y
.ogicieis
1
E GUIDE DE L'ÂMIÔÂ f
d'application et périphériques |
Édité par 1
COMMODORE REVUE |
aiic nt+Ann ah i iachiia
256 PAGES I
vous unena eii Kiosque D'INFORMATIONS SUR L'AMEGA 48 Francs |
INITIATION A L’AMIGA-BASIC
Allez, on se dépêche : on charge l’AmigaBa- sic dans la mémoire de son ordinateur préféré et, prenant son courage à deux mains et sa souris dans l’autre, on se prépare à explorer le fabuleux domaine des variables...
Avant toute chose, je tiens à préciser qu’à partir de dorénavant, maintenant et jusqu’à plus tard, je ne préciserai plus que pour écrire un programme il faut cliquer dans la fenêtre « List » et recopier une à une les lignes, en les validant par la touche RETURN>. Pas plus que je ne répéterai que pour exécuter le programme ainsi tapé, il faut choisir l’option Start dans le menu Run, ou appuyer simultanément sur les touches Amiga et R.
Qu’est-ce donc qu’une variable ? Nous avons tous appris à l’école, en cours de mathématiques (sauf les cancres qui dormaient au fond de la classe...), qu’une variable était un moyen simple de mémoriser une valeur. Par exemple, l’affectation mathématique A = 2 donne la valeur « 2 » à la variable de nom « A ». Par opposition aux constantes, la valeur d’une variable peut-être modifiée à tout instant dans une formule. En Basic, c’est exactement la même chose. Nous pouvons créer des variables en leur donnant un nom et une valeur, ce nom servant à accéder à cette valeur à tout instant. En revanche, alors que d’autres langages de programmation tels le Pascal, le C ou l’assembleur, autorisent des constantes, le Basic ne connaît que les variables.
Cela étant dit, il nous faut maintenant distinguer deux types de variables : les numériques et les alpha-numériques. Une variable numérique ne peut avoir pour valeur, que des nombres définis. Une affectation d’une valeur à une variable se fait exactement de la même manière qu’en mathématiques. Par exemple :
A = 3 B = 34.5
La variable A prend alors la valeur 3, tandis que B égale 34.5 (remarquez que, tout comme sur une calculatrice électronique, on utilise le point comme séparateur décimal).
Nous aborderons dans un autre article les variables alpha-numériques, bien que nous en ayons déjà rencontré une le mois dernier (souvenez-vous de a$ ...).
Il nous faut, encore une fois, effectuer un rapprochement entre le Basic et les mathématiques. Considérons donc les déclarations suivantes : x = 3 y = 5
r = 4x + 2y + 6
N’importe quel écolier de douze ans serait capable de vous dire que pour calculer la valeur de r, nous devrons utiliser celles de x et de y. Essayons donc de traduire cela en Basic : x = 3 y = 5
r = 4*x + 2*y + 6 La seule différence notoire est l’introduction du sigle « * », qui représente, pour l’AmigaBa- sic, l’opérateur de multiplication. Exécuté tel quel, ce programme fonctionne parfaitement et la variable r prend bien la valeur 28, comme l’on s’y attendait. Mais pour l’instant, l’Amiga garde jalousement ce résultat, sans en nous en faire part. C’est simplement parce que nous ne le lui avons pas demandé...
LES NOMS DES VARIABLES
On peut donner a priori n’importe quel nom à une variable. Je dis bien à priori, car il existe quand même certaines restrictions, auxquelles il faut bien se conformer. Premièrement, on ne peut utiliser que des lettres (A à Z, majuscules et ou minuscules) et des chiffres (0 à 9), le point
(.) Et le signe souligné ( ) pour nommer une
variable, et le premier caractère doit obligatoirement être une lettre. Il est évident que les caractères que le Basic peut considérer comme des opérateurs ( + , ,*, etc.), les caractères accentués et les espaces sont interdits. Deuxièmement, la longueur d’un nom de variable est limitée à 32 caractères maximum. Enfin, il est interdit d’utiliser des noms d’instructions Basic !
Exemples de noms de variables valides :
A
prix
vitesse
livre
cercleO
cerclel
Maison.Rouge
Maison Blanche
Maison De Fous
Commodore_Revue
Exemples de noms de variables invalides :
1a Le premier caractère est un chiffre ! Maison Rouge Contient un espace ! Maison-Blanche Contient le signe moins (-) ! Print Est le nom d’une instruction Basic ! ABCDEFGHIJKLMMNOPQRSTUVWXYZ1234 567 Fait 33 caractères de long !
EDITION D’UNE VARIABLE
Pour que l’AmigaBasic nous communique le résultat des calculs qu’il a effectués, nous devons lui dire de le faire. Nous allons pour cela, utiliser une instruction que nous avons déjà rencontrée le mois dernier, à savoir PRINT. Ajoutez donc la ligne suivante au programme ci-dessus :
PRINT r
et exécutez-le à nouveau. Nous avons cette fois-ci atteint notre but et le chiffre 28 s’affiche bel et bien à l’écran.
Que faut-il en déduire? Tout simplement qu’en plus de l’affichage de textes quelconques (cf. Commodore Revue N°12), l’instruction PRINT permet d’éditer à l’écran la valeur d’une variable.
Une remarque au passage : les plus attentifs auront remarqué que nous n’avions pas inclus de guillemets dans l’instruction PRINT r. Ceci est dû au fait que nous désirons que l’Amiga- Basic affiche la valeur de la variable r et non le texte « r ». Il est (bien évidemment ?) Possible de mélanger l’édition de texte et de variables, comme le montre ce petit exemple : numéro = 13 PRINT «Vous lisez Commodore Revue numéro » ; numéro
Notez que l’instruction PRINT est suivie d’un texte entre guillemets, lui-même suivi d’un point-virgule et de la variable numéro. Le point- virgule n’est pas ici indispensable, mais les puristes du Basic préfèrent le mettre. Il agit comme séparateur entre les deux arguments de l’instruction PRINT. Après avoir exécuté ces deux lignes, vous devez obtenir à l’écran la phrase :
Vous lisez Commodore Revue numéro 13
CALCULS AVEC LES VARIABLES
Essayez maintenant le programme suivant : x = 3 y=5
r = 4*x + 2*z + 6 PRINT r
Cette fois-ci, c’est le nombre 18 qui s’affiche. L’explication en est simple : dans le calcul de r, une nouvelle variable baptisée z intervient ; or, il se trouve que nul part dans le programme, nous n’avons affecté de valeur à z. Mais ce n’est pas pour autant que l’AmigaBasic la refuse ; simplement, il considère que sa valeur est nulle (égale à zéro), d’où ce résultat parfaitement juste de 18 (vérifiez, vous verrez bien !). Ce qui nous permet d’énoncer une règle simple mais primordiale : si l’on n’affecte pas de valeur particulière à une variable, celle-ci prend automatiquement la valeur 0.
Modifiez encore yne fois le programme, afin d’obtenir : x = 3
r = 4*x + 2*y + 6 y = 5
PRINT r
Là encore, le résultat affiché est 18 et non
28. Nous avons pourtant bien affecté à y la valeur 5, alors pourquoi ce résultat apparemment incorrect ? La réponse est simple : l’affectation de y se fait APRES le calcul de r ; en d’autres termes, au moment où l’ordinateur calcule r, il ne connaît pas encore y et lui affecte donc la valeur 0. Ce n’est qu’ensuite que y prend la valeur 5. N’oubliez jamais qu’un programme Basic est lu et exécuté séquentiellement, c’est-à-dire « de haut en bas ».
Peut-être serait-il maintenant temps que j’introduise ici les différents opérateurs que le Basic reconnaît. La liste qui va suivre n’est pas exhaustive ; nous en rencontrerons d’autres au fur et à mesure de notre exploration de ce langage.
Opérateur
Opération
Exemple
_
Affectation
A = B
+
Addition
A + B

Soustraction
A B
*
Multiplication
A*B

Division
A B
î
Puissance
A î B
( et )
Priorité
(A + B)*C
MODIFICATION DE LA VALEUR D’UNE VARIABLE
Voilà une notion très importante concernant les variables. Le mot même l’indique : il est possible de modifier la valeur d’une variable, simplement en utilisant l’opérateur d’affectation =. A = 12 PRINT A
A AS
PRINT A
Si vous tapez puis exécutez ces quatre lignes, vous obtiendrez à l’écran les chiffres 12 puis 45. Ce qui s’est passé est très simple : nous avons affecté à la variable A la valeur 12 et affiché cette valeur, puis nous l’avons modifié, simplement en effectuant une nouvelle affectation à A. Ce qui nous amène à dire que nous pouvons, au sein d’un programme, affecter à une variable autant de valeurs que nous le désirons. Et ce qui nous amène également à constater que c’est toujours la dernière valeur affectée à cette variable qui est prise en compte.
Une notion plus difficile maintenant, car déroutante au début. Considérez le programme suivant :
A = 12.36 A = A + 4.102 PRINT A
Après exécution, ce programme affiche à l’écran le nombre 16.462. L’instruction A = A + 4.102 peut à priori vous sembler difficile à digérer. Nous avons en effet déjà vu que nous pouvions nous servir d’une variable donnée pour en calculer une autre, mais là... L’explication est très simple : cette instruction signifie littéralement « prendre la valeur de A, y ajouter le nombre 4.102 et affecter le résultat de cette addition à la variable A ». Cette propriété qu’ont les variables de pouvoir calculer leur nouvelle valeur d’après l’ancienne, va beaucoup nous servir dans la suite de nos expériences en programmation. Il est donc indispensable que vous l’assimiliez...
Voici un exemple qui devrait vous convaincre. Ce court programme est destiné à calculer le prix d’un article quelconque après une ristourne de 20 %, connaissant son prix normal, prix = 125
PRINT «Le prix de cet article est » ;prix ; »
francs.«
ristourne = 20
PRINT « Il y a une ristourne de » ;ris- tourne ;« %.«
prix = prix-((prix*ristourne) 100)
PRINT «Vous devez donc payer » ;prix ; » francs. »
LECTURE DE LA VALEUR D’UNE VARIABLE
Notre petit programme ci-dessus était bien, mais il manquait de convivialité ; il est en effet assez rare qu’un magasin ne propose que des articles à 125 francs, avec des ristournes de 20 % uniquement. En clair, il serait intéressant que nous puissions, d’une manière ou d’une autre, demander à l’utilisateur du programme quels sont le prix initial de l’article et le montant de la ristourne accordée.
Nous allons, pour cela, utiliser une instruction déjà rencontrée dans notre premier article : INPUT. Là où nous l’avions laissée, elle nous permettait d’afficher un texte d’invite, et d’attendre une entrée au clavier de l’utilisateur. Modifiez donc le programme de ristourne pour obtenir ceci :
INPUT « Quel est le prix de cet article » ;prix INPUT « Quel est le montant de la ristourne » ; ristourne prix = prix-((prix*ristourne) 100) PRINT « Le client doit donc payer » ; prix ; » francs. »
Et vous pouvez maintenant donner le prix et le montant de la ristourne que vous voulez, l’ordinateur calculera pour vous le nouveau prix que le client devra payer (faites attention à n’entrer que des nombres, sans spécifier FRANCS ni % !).
Ce que nous venons de démontrer est primordial : l’instruction INPUT permet d’affecter une valeur à une variable, non pas par programme, mais de manière interactive. Dès lors, tous les rêves sont permis...
A BIENTOT
La notion de variable devrait maintenant être claire aux yeux de tous ; mais comme nous le verrons le mois prochain, il y a encore beaucoup à dire sur le sujet, notamment en ce qui concerne les différents types de variables numériques, ainsi que sur les variables alphanumériques. Si vous désirez en savoir plus sur le sujet, ou sur l’AmigaBasic en général, n’hésitez surtout pas à m’écrire au journal, ou mieux, dans ma boîte-à-lettres DESCOINS sur le serveur 3615 COMREV. A bientôt.
Michel Descoins
>FRANCS ni % !). Ce que nous venons de démontrer est primordial : l’instruction INPUT permet d’affecter une valeur à une variable, non pas par programme, mais de manière interactive. Dès lors, tous les rêves sont permis...
A BIENTOT
La notion de variable devrait maintenant être claire aux yeux de tous ; mais comme nous le verrons le mois prochain, il y a encore beaucoup à dire sur le sujet, notamment en ce qui concerne les différents types de variables numériques, ainsi que sur les variables alphanumériques. Si vous désirez en savoir plus sur le sujet, ou sur l’AmigaBasic en général, n’hésitez surtout pas à m’écrire au journal, ou mieux, dans ma boîte-à-lettres DESCOINS sur le serveur 3615 COMREV. A bientôt.
Michel Descoins

Click image to download PDF

AMIGA NEWS TECH numero 02 (06-1989)

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


Thanks for you help to extend Amigaland.com !
frdanlenfideelhuitjanoplptroruessvtr

Connexion

Pub+

37.5% 
16.7% 
5.6% 
4.3% 
3.8% 
3.4% 
3.2% 
2.1% 
1.8% 
1.2% 

Today: 111
Yesterday: 84
This Week: 338
Last Week: 581
This Month: 2202
Last Month: 2550
Total: 68892

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