Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 15:44  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Quizz
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Trucs et astuces
 · Articles divers

 · Articles in english


Twitter

Suivez-nous sur Twitter




Liste des jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z,
ALL


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Galeries

 · Menu des galeries

 · BD d'Amiga Spécial
 · Caricatures Dudai
 · Caricatures Jet d'ail
 · Diagrammes de Jay Miner
 · Images insolites
 · Fin de jeux (de A à E)
 · Fin de Jeux (de F à O)
 · Fin de jeux (de P à Z)
 · Galerie de Mike Dafunk
 · Logos d'Obligement
 · Pubs pour matériels
 · Systèmes d'exploitation
 · Trombinoscope Alchimie 7
 · Vidéos


Téléchargement

 · Documents
 · Jeux
 · Logiciels
 · Magazines
 · Divers


Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Logiciels
 · Jeux
 · Scène démo
 · Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


En pratique : Comment programmer un jeu en assembleur - 1re partie
(Article écrit par l'équipe de Bullfrog et d'Amiga Format - octobre 1992)


Note : traduis et retravaillé par Kamel Biskri en décembre 2020.

Ci-dessous, quatre membres de Bullfrog, les personnes derrière ce tutoriel. Avez-vous déjà entendu parler de Populous 1 et 2 ? Ce sont les personnes ayant créé ces jeux. L'équipe de Bullfrog ne se lance pas dans des techniques de programmation trop compliquées ou approfondies. Elle aime garder les choses simples.

Tutoriel assembleur

A votre tour ! Comment programmer vos propres jeux en assembleur

Si vous avez toujours voulu devenir programmeur de jeux, c'est maintenant votre chance. Un assembleur complet est disponible sur la disquette de couverture, plus un "kit" de code "pour débutants" et un tutoriel complet du programmeur de Bullfrog Scott Johnston. Vous ne pensiez pas pouvoir apprendre d'un article de magazine ? Vous pouvez le croire ! C'est ainsi que Scott a appris !

Quelle meilleure façon d'apprendre à programmer qu'avec les experts de Bullfrog, l'équipe de programmation derrière le légendaire Populous 2 ? Et quelle meilleure personne pour apprendre qu'avec un programmeur qui fait partie maintenant de cette équipe ? Et savoir comment tout ceci fonctionne à partir d'un article de magazine ?

Le chef de Bullfrog, Peter Molyneux, explique : "Il y a de cela un an environ, lorsque ST Format (le magazine frère d'Amiga Format pour l'ordinateur 16 bits Atari ST) a lancé une série que nous avons écrite pour eux afin d'enseigner aux gens comment programmer, Scott Johnston a répondu à une offre de stagiaire chez nous."

Bullfrog accueille régulièrement des stagiaires et leur apprend à coder, et place aussi des jeunes dans un environnement de travail, c'est pourquoi ils disposent d'un système de formation bien établi qui constitue la base de cette série. Bref, revenons à Peter...

"Nous n'avions pas de travail pour Scott à l'époque, donc nous ne pouvions pas le prendre. Quoi qu'il en soit, Scott est parti à l'université et a appris à programmer à partir de la série sur Atari ST Format. Un an plus tard, nous étions en mesure de le prendre, et à ce moment-là, il savait déjà coder." Cela ne fait que prouver que vous le pouvez aussi.

Ce que nous avons pour vous, c'est le langage d'assemblage DevPac 2. Le langage d'assemblage est utilisé dans presque tous les jeux Amiga professionnels, car rien d'autre n'est assez rapide. Nous avons également du code fourni par Bullfrog, qui est exactement celui utilisé dans Populous 2 et qui gère une grande partie de la configuration délicate du matériel, vous laissant ainsi aller dans les moindres détails de la création d'un jeu.

Au cours de la série, le code fourni par Bullfrog se transformera en un jeu d'arcade complet. Ce ne sera peut-être pas la chose la plus étonnante que vous ayez jamais vue, mais ce sera votre propre travail !

Il s'agit de MonAm2, le moniteur intégré de DevPac. Vous n'aurez pas besoin de l'utiliser pour ce tutoriel, mais pour les curieux, c'est un programme qui traduit du code machine en assembleur. Il est aussi très utile pour trouver des erreurs.

Tutoriel assembleur

Idée de base

Juste avant de commencer, examinons l'idée de base du fonctionnement d'un jeu. Le tout est construit autour de ce que l'on appelle la "boucle principale du jeu". C'est un processus de vérification, à chaque fraction de seconde, de tout ce qui se répète. Une boucle de jeu principale typique pour un jeu d'arcade pourrait être quelque chose comme ça...
  • En un : vérifier la manette.
  • En deux : déplacer le sprite en conséquence.
  • En trois : vérifier les collisions - si une collision a eu lieu, diminuer l'énergie.
  • En quatre : vérifier l'état du compteur du jeu - s'il n'y a plus d'énergie, c'est fini.
  • Ensuite, revenir au début de la boucle.
Cela donnerait un jeu dans lequel un sprite se déplace en se cognant contre des objets et qui finit par mourir. Évidemment, il faudra alors ajouter d'autres choses : si le bouton de tir est enfoncé, lancer une animation de balle. Si des ennemis se déplacent sur l'écran, les déplacer après le sprite. Vérifier si les balles ont touché les ennemis. Si c'est le cas, se débarrasser d'eux et incrémenter le score du joueur et ainsi de suite. Voilà la base.

Sprite à l'écran

Là où nous devons commencer, bien sûr, c'est obtenir un sprite sur l'écran et le déplacer. C'est ce que nous allons couvrir ce mois-ci. Mais d'abord, passons à Scott Johnston pour qu'il vous présente quelques notions de base...

Tout programmeur sérieux vous dira que la beauté de la programmation en langage assembleur réside dans la vitesse que l'on peut atteindre. Il est facile de faire en sorte que votre Amiga produise une animation de qualité, mais lorsque l'on veut transformer une séquence d'animation en un jeu, on doit commencer à lire la position de la manette, répondre aux mouvements du joueur et suivre les ennemis. Tenter de regrouper toutes ces routines dans un programme en langage BASIC tout en continuant à le faire fonctionner à plein régime serait un cauchemar.

Le langage assembleur est si rapide que c'est l'alternative idéale. Actuellement, l'outil de programmation en langage assembleur le plus populaire est DevPac de HiSoft, bien qu'ils aient sorti une nouvelle version, DevPac 2, fournit un éditeur et un assembleur complet vous permettant de créer et d'éditer vos propres programmes. La manière dont on modifie, assemble puis exécute un programme est expliquée en détail ci-dessous.

Comment utiliser la disquette (téléchargement)

Nous avons essayé de rendre l'utilisation de Devpac aussi indolore que possible. Lorsque la disquette démarre, on se retrouve dans l'éditeur de texte du programme. C'est là que vous écrirez vos programmes, même si pour cette première partie la grande majorité des programmes ont déjà été écrits pour vous.

La chose la plus importante à retenir à propos du code machine est que le code lui-même est composé de nombres. Les ordinateurs ne comprennent que les nombres ou le code objet comme on l'appelle parfois. Cependant, les gens n'écrivent pas de programmes en utilisant uniquement des nombres, mais utilisent à la place un langage spécial appelé langage d'assemblage ou assembleur. Cela ne peut pas être compris directement par l'ordinateur et est appelé code source.

Un assembleur comme Devpac prendra tout le code source (assembleur) et le traduira directement en code objet (machine). Il peut aussi faire beaucoup plus. Par exemple, il y a un moniteur pour visualiser vos programmes pendant qu'ils fonctionnent, mais c'est le strict minimum. Soit dit en passant, si on entre accidentellement dans le moniteur, il suffira d'appuyer plusieurs fois sur la touche "Entrée", puis sur "Ctrl-C" pour revenir à l'éditeur.

Enfin, quelques notes sur les commandes spéciales de Devpac. Si une ligne commence par un point-virgule (;), Devpac l'ignorera (commentaire). Utile pour cacher des parties d'un programme dont vous n'aurez pas besoin.

Lorsque vous voyez une commande comme "DC.B" ou "DC.W" ou "DC.L", il s'agit simplement d'une zone de données dans laquelle les variables doivent être stockées. Le mot de commande "Even" sert à s'assurer que les zones de données sont d'égale longueur (sinon l'Amiga a tendance à planter).

Quoi qu'il en soit, voici comment charger le code source :

1. Déplacez le pointeur de la souris en haut à gauche de l'écran et maintenez le bouton droit de la souris enfoncé. Un menu se déroulera. Sélectionnez "Load" dans le menu "Project", un gestionnaire de fichier apparaîtra.

Tutoriel assembleur

2. Un conseil pratique pour ce gestionnaire de fichier, c'est de cliquer sur le curseur (ascenseur) sur le côté droit et de le déplacer de haut en bas. La liste des fichiers sera automatiquement triée par ordre alphabétique. Trouvez et double-cliquez sur le fichier appelé "demo.s". Il se chargera et s'affichera.

Tutoriel assembleur

3. Pour le transformer en code machine, sélectionnez "Assemble" dans le menu "Program". Une liste d'options apparaîtra. Cliquez simplement sur "Memory" puis sur "Assemble". Devpac mettra l'assembleur en marche et vous demandera d'appuyer sur une touche quand il aura terminé.

Tutoriel assembleur

4. Pour lancer le programme, sélectionnez simplement l'option "Run" dans le menu "Program". La démo s'exécutera, affichant un sprite. Tapez sur la lettre "Q" pour quitter.

Tutoriel assembleur

Séquence d'animation

Les programmes en langage d'assemblage correspondent au langage machine de votre Amiga, ils sont donc beaucoup plus complexes à écrire que les programmes en BASIC, mais ne vous décourages pas.

Dans ce numéro, nous commençons un tutoriel complet sur la programmation en langage d'assemblage et nous le rendons si simple que même un chat pourrait l'utiliser. Pour commencer, nous allons voir comment construire une séquence d'animation.

La disquette contient un simple "Shell" pour écrire des programmes en assembleur, ainsi que des routines ayant servies à créer Populous 2, y compris certains des dessins de sprites et tous les dessins d'écran. Tout ce dont vous avez besoin pour changer d'écrans, dessiner des sprites, etc.

Avec ce Shell, vous n'aurez pas à parcourir des tas de manuels de référence pour savoir comment configurer des écrans ou afficher des sprites : tout a été fait pour vous. Au cours de plusieurs mois, nous allons créer un jeu très simple, mais vous aurez besoin de plusieurs éléments pour aller jusqu'au bout.
  • Enthousiasme. Oui, je sais, cela semble évident, mais vous ne serez toujours qu'un programmeur standard à moins que vous ne veuillez vraiment bien faire.
  • Ce serait bien si vous pouviez lire un livre sur l'assembleur 68000 (Amiga Format recommande le livre Amiga Machine Language d'Abacus - ISBN 1557550255).
  • Savez-vous ce que sont le binaire et l'hexadécimal ? Sinon, essayez de le découvrir en achetant un manuel de référence dans une librairie.
Bon, enthousiasme prouvé, nous sommes prêts à continuer. Comme pour tout projet de programmation quel que soit le langage que l'on utilise, la première étape consiste à concevoir les sprites dont on a besoin en utilisant un paquet artistique. Vous n'avez pas besoin de les faire vous-même car nous avons inclus des sprites sur la disquette, mais voici comment procéder, et le mois prochain, nous fournirons un utilitaire qui vous permettra d'utiliser vos propres sprites dans le jeu que nous créerons.

Un total de neuf sprites sont utilisés pour le sprite de la démo. Ils semblent probablement déformés et irréels pour la plupart des gens à cette échelle, mais ils seront très bien à l'écran.

Tutoriel assembleur

Il existe plusieurs paquets artistiques courants qui conviennent, mais Bullfrog a tendance à traiter ses visuels prédessinés avec Deluxe Paint III ou IV. En fait, la plupart des programmeurs qui travaillent sur un Amiga utilisent Deluxe Paint. Mais quel que soit le paquet artistique que vous utilisez, la première étape consiste à configurer une grille de huit par huit pixels.

Créez un damier ou une grille dans laquelle dessiner les sprites. "Personnellement, je préfère l'approche en damier, mais j'ai vu des graphistes se battre pour savoir quelle était la meilleure méthode", explique le patron de Bullfrog, Peter Molyneux. Maintenant, allez-y et concevez vos sprites en les gardant dans les limites de votre grille.

Une fois vos sprites pour les étapes de l'animation dessinés, vous devrez les placer dans l'ordre en commençant par le point supérieur gauche de l'écran et en progressant. Une fois que vous atteindrez le côté droit de l'écran, descendez d'une ligne et continuez.

Il est essentiel à ce stade de comprendre le format d'écran de l'Amiga. Chaque pixel d'un écran basse résolution est stocké sous forme de quatre bits dans quatre groupes de quatre bits différents appelés mots. Ils sont connus sous le nom de plans de bits (bitplanes), et comme il y en a quatre, vous avez 16 combinaisons possibles (1 bit x 4 plans, ou quatre à la puissance de deux) pour chaque pixel, d'où une palette de 16 couleurs.

Les quatre mots différents sont stockés à différents points de la mémoire, avec tous les mots du premier plan (plan 0) stockés en mémoire ensemble, suivis du plan 1 et ainsi de suite. La mémoire ressemble à quelque chose comme ceci :

Début du plan 0
8000 octets
Début du plan 1
8000 octets
etc.

La méthode la plus efficace pour stocker un sprite en mémoire, afin que vous puissiez y accéder pour un dessin rapide, consiste à stocker chaque ligne du sprite sous forme de quatre mots pour les 16 premiers pixels de la ligne, quatre mots pour les 16 pixels suivants et ainsi de suite... C'est pourquoi presque toutes les routines de sprites ne s'adressent qu'aux sprites qui sont un multiple de seize pixels de large : 16, 32, 48, 64 et ainsi de suite.

Comme nous l'avons dit, inclus sur la disquette du mois prochain, un programme de conversion qui acceptera les fichiers IFF de paquets artistiques comme Deluxe Paint sera inclus. Il convertira ensuite vos graphiques en données utilisables par le programme. Juste pour ce mois-ci, utilisez nos graphismes.

Ok, l'introduction ennuyeuse est faite, jetons un coup d'oeil à la disquette. Si vous assemblez d'abord le fichier "demos.s", puis que vous exécutez Demo (les instructions d'assemblage et d'exécution se trouvent dans la partie intitulée "Comment utiliser la disquette"), un sprite s'affichera à l'écran. Pour quitter le programme, appuyez sur la touche "Q". Génial. Voilà. Quoi ? Vous en voulez plus ?

Nous ne changerons jamais le fichier "demos.s" - enfin, du moins pas très souvent. Chaque fois que vous souhaitez assembler ce programme, enregistrez d'abord le fichier que vous utilisez, puis chargez-le dans "demo.s". Lors de l'assemblage, utilisez "Output to memory", puis vous pourrez tester le programme simplement en utilisant la commande "Run". De cette façon, vous ne sauvegarderez pas la démo modifiée sur la disquette au risque d'écraser l'ancienne version.

Essayons maintenant de déplacer le sprite. Jetez un oeil au fichier "draw.s" dans la routine :

_draw_all

...et vous verrez que nous avons le morceau de code suivant :

move.w #0,d0
move.w #0,d1
move.w #0,d2

Maintenant, si vous changez cela en...

move.w man_x,d0
move.w man_y,d1
move.w man_frame,d2

Bien, les impatients parmi vous l'auront déjà assemblé. Aucun changement n'est visible, bien sûr que non, mais si vous éditez le fichier "move.s" et que vous supprimez les ";",  alors notre sprite devrait commencer à se déplacer vers la droite et revenir au début quand il aura atteint la fin de l'écran.

Le fonctionnement de ces instructions est le suivant. Tout d'abord, nous incrémentons (augmentons) la valeur de la coordonnée x de l'homme de 1 à chaque tour. La valeur est alors comparée à 304 (le bord de l'écran) et si elle est supérieure à cela, la position est remise à 0. Sinon, nous sautons par-dessus la commande de réinitialisation. La valeur est ensuite stockée dans man_x, prête pour le prochain affichage.

Vous pouvez modifier la valeur dans la commande "add" pour augmenter la vitesse de déplacement.

Prenons le temps pour expliquer deux ou trois choses: "d0" est un registre, qui est essentiellement juste une zone de la mémoire dans laquelle vous pouvez stocker une valeur. Une variable est un nombre qui change, en gros, vous pouvez donc ajouter à une variable pour affecter ce que fait votre programme. J'espère que c'est assez simple pour continuer. Quoi qu'il en soit, la façon dont toutes ces choses fonctionnent deviendra claire avec de la pratique.

Un petit défi pour vous : voyez si vous pouvez écrire le code pour déplacer l'homme vers le bas de l'écran. Le code sera fondamentalement le même que celui de "move x", mais rappelez-vous que la taille de l'écran est de 320 par 200 pixels, et que l'étiquette "lessthanx" a déjà été utilisée, alors utilisez quelque chose de différent.

Une note sur les étiquettes : nommez-les en leur donnant du sens ou vous oublierez ce qu'elles font plus tard. Avoir six étiquettes avec le nom ".here" n'est pas très utile.

Nous devrions à ce stade avoir l'homme qui se déplace en bas et au travers de l'écran. Mais cela souligne un problème : il bouge comme s'il flottait. L'homme ne marche pas vraiment. Mettons-y un peu d'animation.

Pour ce faire, nous prenons la même routine que celle utilisée dans le mouvement, mais changeons quelques choses. Si vous n'êtes toujours pas sûr de déplacer l'homme vers le bas de l'écran, le prochain morceau de code devrait vous aider, il animera le sprite et devra être ajouté dans le fichier "Move.s", avant la commande RTS finale.

        move.w man_frame,d2
        add.w #l,d2
        cmp.w #4,d2
        ble.s .lessthana
        move.w #0,d2
.lessthana
        move.w d2,man_frame

Attention, nous n'avons que quatre images d'animation avec lesquelles jouer, alors ne définissez pas la commande de comparaison trop élevée.

Assemblez ceci et jetez-y un oeil. Il change d'étapes un peu vite, trop vite en fait, nous devons donc le ralentir. Pour ce faire, changez la ligne :

        cmp #4,d2

...par :

        cmp #4*4,d2

Réduisez également le nombre. Après la ligne :

          move.w man_frame,d2

Dans "draw.s", placez le morceau de code suivant :

          asr.w #2,d2

Assemblez ceci, et l'homme devrait marcher un peu plus lentement.

Ainsi, en seulement un mois, nous avons un sprite animé se déplaçant sur l'écran et vous avez appris certaines des commandes les plus importantes. Le mois prochain, nous devrons mettre notre homme sous le contrôle de la manette. A plus tard.

Le coeur de la machine : le processeur central MC68000

La puce qui prend les décisions et exécute les programmes dans la plupart des Amiga est le Motorola 68000. Certains Amiga ont des versions plus puissantes, les grands frères si vous voulez, mais les différences sont assez mineures, sauf que les plus grosses machines vont plus vite.

Si vous n'êtes pas sûr du fonctionnement de la mémoire de l'ordinateur, tout ce que je peux faire est de vous conseiller de lire et de digérer la rubrique "Answerfile", disponible à la fois à la page 221 de ce numéro et à la page 199 d'Amiga Format du mois dernier. Cela vous donnera beaucoup d'informations sur la manière dont l'Amiga traite les informations.

Le fonctionnement du 68000 n'est pas trop difficile à comprendre. À l'intérieur de la puce se trouvent des emplacements pour les nombres, un peu comme de la mémoire, sauf qu'ils peuvent être manipulés directement par la puce. Ils sont appelés registres et peuvent être ajoutés, multipliés et testés. Si un nombre est trop grand ou trop petit, un saut peut être fait vers une autre partie d'un programme, c'est ainsi que le 68000 prend des décisions.

Il existe différents types de registres. Ceux qui pointent vers des zones de la mémoire de l'Amiga sont appelés registres d'adresses. Il y en a huit et leurs noms sont assez ennuyeux : A0, A1, A2, A3, A4, A5, A6 et A7. En utilisant les routines de Bullfrog sur la disquette de couverture Collection, vous aurez rarement besoin d'utiliser les registres d'adresses.

Les registres de données sont bien plus importants pour nos besoins. Ceux-ci sont utilisés pour stocker les nombres à manipuler. Ils sont appelés D0, D1, D2, D3, D4, D5, D6 et D7. Il existe d'autres registres de données, mais laissons-les de côté un instant. Dans ce numéro, vous n'aurez qu'à vous soucier des trois premiers, ceux-ci sont utilisés pour stocker la coordonnée X (D0), la coordonnée Y (D1) et le numéro d'image du sprite (D2).

Il existe d'autres registres, dont les plus importants d'entre eux sont les registres PC (Program Counter) et Status (généralement appelé SR). Le PC conserve en mémoire l'adresse de l'emplacement actuel du programme, lorsque on passe à une adresse différente, tout ce qui se passe, c'est que le PC se voit attribuer un nouveau point de départ.

Le registre d'état contient de nombreux indicateurs, qui gardent une trace des choses par exemple si la dernière instruction a abouti à zéro ou à un nombre négatif, et des conditions similaires.

Ainsi, dans cet exemple, lorsque le numéro d'image de l'animation est comparé à 4 et est inférieur ou égal à ce nombre, le programme continu. Lorsqu'il est supérieur à cela, le compteur de trames est remis à zéro. Il existe d'autres étapes d'animation, mais si vous les utilisez, votre homme se tournera vers vous en marchant.

Il existe d'autres registres pour effectuer différentes tâches à l'intérieur du MC68000, mais vous n'avez pas encore besoin de les connaître. Ce qui est plus important, c'est que vous comprenez ce qui précède, c'est tout ce que vous devez comprendre pour utiliser ce tutoriel.

Pour les curieux. Je vais vous parler de certaines autres parties concernant le code machine, les parties que Bullfrog vous a fournies qui incluent de nombreuses routines pour faire le sale boulot à votre place.

Il y a un bloc mémoire qui est réservé à l'utilisation des puces personnalisées de l'Amiga. On y accède comme de la mémoire normale, mais on ne peut pas l'utiliser pour stocker de l'information. Ils en existent de trois types de base, registres en lecture seule, que le 68000 peut lire mais pas écrire ; registres en écriture seule, auxquels le 68000 peut écrire mais pas lire ; et des registres de lecture/écriture, auxquels il peut lire et écrire.

Ces registres matériels sont la passerelle entre le 68000 et l'Amiga. Par exemple, si vous définissez l'un des commutateurs binaires dans un certain registre, l'affichage passera de basse résolution à haute résolution.

Ce n'est pas si simple, loin de là. Par exemple, pour que la puce Paula joue un échantillon sonore, vous devez lui indiquer où se trouve l'échantillon en mémoire, à quelle vitesse jouer et quels canaux utiliser. Gardez à l'esprit que vous devez le faire en utilisant des nombres hexadécimaux et vous comprendrez que communiquer directement avec matériel peut être un cauchemar.

Si vous voulez voir à quel point cela est impliqué, utilisez l'éditeur Devpac pour charger les autres fichiers répertoriés dans "demo.s". Certains d'entre eux sont assez longs. La quantité de programmation que l'on doit écrire même pour les plus petites tâches, comme ouvrir un écran personnalisé, lire la manette et afficher un sprite est assez énorme.

Cependant, pour ceux qui sont intéressés, les routines de Bullfrog se révéleront très utiles. Beaucoup de gens sont perplexes avec la programmation parce qu'ils n'ont pas assez d'exemples sur lesquels travailler.

Le problème est que jusqu'à présent, il n'y avait pas beaucoup de code machine professionnel disponible pour vous permettre de lire et d'apprendre. Essayez d'en apprendre le plus possible en lisant les sources fournies, la plupart contiennent de la documentation.

Aperçu des commandes

move.w #l, d0

La commande "move" est l'une des commandes les plus utilisées. Pour simplifier, nous utilisons "move.w" - le "w" signifie uniquement des données de la taille d'un mot (16 bits). C'est l'équivalent de l'instruction "LET" en BASIC. Il charge x (un nombre) dans d0.

add.w #l, d0

La commande "add" fait exactement cela : elle ajoute la valeur 1 à d0.

sub.w #l, d0

La commande "sub" est similaire à l'addition mais soustrait à la place.

cmp.w #l, d0

La commande "cmp" compare la valeur 1 à la valeur de d0. Lorsqu'il est utilisé en conjonction avec une instruction de branchement, elle est similaire à l'instruction "IF" que l'on trouve dans le langage BASIC.

Branchement

Les instructions de branchement vérifient les indicateurs définis par l'instruction "compare". Il existe 15 versions différentes de cette commande :

bra Branchement inconditionnel. Identique à GOTO.
bcc Branchement si la retenue est à zéro (C=0)
bcs Branchement si la retenue est à 1 (C=1)
beq Branchement si égal (Z=1)
bge Branchement si supérieur ou égal à (N xor V=0)
bgt Branchement si supérieur à (Z + [N xor V] = 0)
bhi Branchement si supérieur (C + Z = 0)
ble Branchement si inférieur ou égal à (Z + [N xor V] = 1)
bls Branchement si inférieur ou égal à (C + Z = 1)
blt Branchement si inférieur à (N xor V = 1)
bmi Branchement si négatif (N=1)
bne Branchement s'il n'est pas égal à (Z=0)
bpl Branchement si positif (N=0)
bvc Branchement si dépassement (V=1)
bvs Branchement si pas de dépassement (V=0)

Ne vous inquiétez pas vous ne comprenez pas tout. En les utilisant, vous vous familiariserez rapidement avec leur fonctionnement. Quoi qu'il en soit, lorsque la condition est vraie, la branche est prise. Sinon, nous passons à l'instruction suivante.

Étiquettes (labels)

Vous aurez remarqué que certaines des étiquettes ont un "." devant elles : on les appelle des labels locaux. Cela signifie que vous pouvez utiliser des mots comme ".finished" plus d'une fois, mais pas dans la même routine. Les routines sont définies par des étiquettes qui n'ont pas de point "." devant eux sont terminées par une commande RTS.

jsr

Aller au sous-programme. Cette commande est fondamentalement la même que la commande GOSUB.

rts

C'est fondamentalement la même chose que la commande RETURN.

asr.w #l, d0

La commande "asr" signifie décalage arithmétique à droite et fonctionne en déplaçant un nombre binaire vers la droite un nombre défini de fois. Par exemple, sur l'instruction ci-dessous :

asr.w #1,10

Nous obtenons une réponse de 5. C'est parce que 10 en binaire ressemble à ceci :

%1010 = 10

Et quand nous le déplaçons une fois vers la droite, il devient :

%0101 = 5

Il y a beaucoup d'autres commandes de décalage, rotation et trancher, mais il n'y a pas vraiment de place pour les décrire ici.

Si vous voulez le meilleur guide sur le 68000, le plus complet et celui qui fait autorité, essayez d'obtenir une copie du livre de Sybex's "Programming the 68000" (23,95 £ chez Computers Manuals 021-706 6000). C'est très pratique pour rechercher des commandes particulières.

Oups !

Si vous quittez Devpac, vous accédez à certains fichiers 'Readme" ("Lisez-moi") sur la disquette. Malheureusement, les regarder ne peut être fait sur les machines avec un Workbench 2.0. Pire encore, cela fait planter d'autres Amiga ! La raison est que dû à un oubli, la mauvaise version du programme d'affichage de texte (ppmore) a été incluse.

Mettre la bonne version sur la disquette (copié à partir de la disquette de couverture Pinball/Caesar) est assez facile. Démarrez la disquette jusqu'au Workbench, doublez-clique sur le Shell et tapez :

Copy from Coverdisk39b:c/ppmore to Devpac2:c

Après un échange de disquette ou deux, le bon programme sera copié et vous pourrez afficher les documents. Ils ne sont pas du tout nécessaires lors de l'utilisation de Devpac, mais nous voulions vous en parler juste pour être sûr.

Mise à niveau vers le dernier DevPac - et nouvelles d'une grande compo de programmation !

Lorsque vous utilisez DevPac depuis suffisamment de temps, vous pourrez en conclure que c'est exactement ce que vous recherchiez dans une trousse de développement. Vous pourrez être mordu par le bogue ! Si tel était le cas, vous pourrez toujours effectuer une mise à niveau du meilleur environnement de programmation en assembleur.

DevPac 3 est probablement le seul langage de programmation primé au Format Gold.


[Retour en haut] / [Retour aux articles]