 |
Lundi 14 septembre 2026 - 11:19 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Ce tutoriel vous permettra d'apprendre à programmer sur Amiga avec AmigaOS et le Workbench. Vous découvrirez comment créer une interface graphique ou un jeu en utilisant les fonctionnalités intégrées du BASIC et la puissance d'AmigaOS pour développer des applications Amiga. Des exemples de code sont fournis pour faciliter votre compréhension.
|
1. Les bases de la programmation 2. Construction - qu'est-ce que la programmation ? 3. Les structures 4. Les sous-routines 5. Entrées et sorties 6. Ouverture d'un écran 7. Ouverture d'une fenêtre 8. Définition des menus 9. Gadgets 10. Graphismes linéaires 11. Sprites et BOB 12. Entrée et sortie de fichiers 13. Son 14. Ouverture d'une bibliothèque 15. Fonctions intégrées |
1. Les bases de la programmation [retour au plan]
Qu'est-ce que le BASIC ?
BASIC signifie "Beginners All purpose Symbolic Instruction Code" (Code d'instructions symboliques universel pour débutants). Ce langage est conçu pour les débutants en programmation et peut être utilisé pour différents types d'applications grâce à des instructions simples à comprendre. Ces instructions peuvent être aussi simples que INPUT, PRINT, LET, etc. L'Amiga propose plusieurs versions de BASIC, notamment AmigaBASIC, ABasic, HiSoft Basic, Ace Base, AMOS, Blitz Basic, AmiBlitz3 et d'autres.
Mémoire
Pour que les ordinateurs traitent et stockent des informations, ils doivent allouer et accéder à ces informations en mémoire. En programmation, on utilise donc des variables, qui sont simplement des zones de mémoire nommées où le programme peut stocker des informations telles que des nombres ou du texte. On parle de variables car leur contenu peut changer.
A) Variables
Le nom d'une variable peut comporter de un à plusieurs caractères, être alphanumérique et commencer par une lettre. Par exemple : count, name, total, age, address, balance, TotalUsers, Number501, etc. Dans certains langages, les variables doivent être définies avant d'être utilisées. Cela permet de déterminer leur contenu et d'allouer de la mémoire pour stocker ces informations. En BASIC, par exemple, on peut utiliser les instructions DEF et DIM. L'instruction DEF est facultative en BASIC.
Types de variables : Integer est un nombre entier (par exemple : 1, 2, 45, 193), float est un nombre décimal (par exemple : 3,1 ; 4,1234 ; 100,9 ; 0,6666), long est un nombre très long (par exemple 12372905), char est un caractère unique (par exemple : "M"), et text est une chaîne de caractères (par exemple : "LONDON").
Par exemple
DEFINT number ' Définit un nombre entier DEFLNG number long ' Définit un entier long DEFSNG number ' Définit un nombre de longueur unique DEFSTR code$ ' Définit une variable de type chaîne de caractères appelée code DEFDBL longvalue ' Définit une variable à virgule flottante double précision |
Remarque : le texte après l'apostrophe (') est appelé commentaire ou remarque ; il sert à documenter le code. Vous pouvez également placer des remarques sur des lignes distinctes, à condition qu'elles commencent par l'instruction "REM".
Notez que les variables de type chaîne de caractères, qui stockent des lettres, des chiffres et d'autres symboles, se terminent toujours par le signe dollar ($) pour indiquer qu'il s'agit d'une chaîne. Pour affecter des valeurs à des variables, vous utilisez l'instruction d'affectation ou LET, qui se présente sous la forme : [LET] variable = expression, où "variable" est la variable de destination et "expression" est une valeur, une formule ou tout autre élément pouvant renvoyer une valeur. La partie "LET" est facultative.
number = 129 nom$ = "Simon Walker" ' Remarque : les caractères et les valeurs de chaîne sont toujours entourés de guillemets count = 1 code$ = "A" |
Pour rendre les programmes plus utiles, vous pouvez également effectuer des opérations arithmétiques telles que l'addition, la soustraction, la multiplication, la division, etc. Vous trouverez ci-dessous une liste des symboles arithmétiques :
- + : ajouter
- - : soustraire
- * : multiplier
- / : diviser
- ^ : puissance
number = (100 + 58) / 2 |
Notez que "100 + 58" est entre parenthèses. En programmation, les multiplications et les divisions sont calculées avant toute addition ou soustraction. Sans parenthèses, le résultat serait "100 + 29 = 129" au lieu de "158 / 2 = 79" (avec les parenthèses). Vous pouvez également utiliser des variables dans vos expressions, comme suit :
number = (150 + number2) / number3 |
Donc, si la variable "number2" contient 60 et la variable "number3" contient 10, le résultat serait (150 + 60) / 10 = 21.
B) Tableaux
Les variables conviennent pour stocker des valeurs uniques, mais si vous souhaitez stocker des dizaines ou des centaines de valeurs, utiliser autant de variables (par exemple, number1, number2, number3 à number100) serait fastidieux et inefficace. Il est donc préférable d'utiliser un tableau, c'est-à-dire une collection de variables portant le même nom. Un tableau possède un index, qui permet d'accéder à n'importe quelle valeur individuelle grâce à la syntaxe : nom_du_tableau(index). L'index peut être un nombre ou une autre variable, ce qui rend les tableaux particulièrement adaptés aux boucles, notamment aux boucles avec comptage. Il est nécessaire de déclarer les tableaux au préalable à l'aide de l'instruction DIM, comme pour les variables, et de spécifier le nombre maximal de valeurs entre parenthèses (n).
Number DIM (100) |
Par exemple, si vous souhaitez stocker tous les nombres de 1 à 100 dans le tableau appelé "numbers", vous pouvez utiliser une boucle "for".
FOR count=1 TO 100 numbers(count) = count NEXT count |
La boucle "for" fonctionne ainsi : elle initialise une variable appelée "count" à la valeur 1, puis vérifie que la condition "count<=100" est vraie avant d'exécuter les instructions entre les instructions "for" et "next". Lorsqu'elle atteint l'instruction "next", elle incrémente la valeur de "count" de 1 et répète la boucle jusqu'à ce que "count" atteigne 100.
Pour accéder au 56e élément du tableau "numbers", vous pouvez procéder ainsi :
mynumber = numbers(56) |
Vous pouvez également initialiser un tableau avec des constantes à l'aide des instructions READ et DATA :
DIM figures(10) FOR count=1 TO 10 READ figures(count) NEXT count DATA 45, 67, 123, 59, 12, 4, 23, 89, 66, 90 |
Nous avons ici un tableau nommé "figures" pouvant stocker dix nombres. La boucle "FOR...NEXT" compte de 1 à 10 et utilise l'instruction "READ" pour lire la valeur suivante renvoyée par l'instruction "DATA" et la stocker dans le tableau "figures" en utilisant le compteur comme index.
Pour les chaînes de caractères, on peut utiliser des tableaux simples. On spécifie donc une valeur entre parenthèses, qui correspond au nombre de chaînes. Dans cet exemple, nous avons quatre chaînes représentant des pays.
DIM countries$(4) countries(1) = "France" countries(2) = "Allemagne" countries(3) = "Pologne" countries(4) = "Italie" |
Vous pouvez créer des tableaux plus grands en ajoutant des dimensions. Par exemple, pour un tableau 8x8 (pour une partie d'échecs, par exemple), ajoutez une valeur d'index à l'instruction DIM :
DIM chessboard(8,8) |
Vous pouvez ensuite placer ou récupérer un élément sur le plateau en utilisant les valeurs d'index :
ROW = 4 COL = 3 chessboard(ROW, COL) = WHITE |
2. Construction - qu'est-ce que la programmation ? [retour au plan]
En termes de vocabulaire, un programme est l'action ou le processus de planification ou d'écriture d'un programme. Un programme est un ensemble d'instructions qui traite des données d'entrée et produit un résultat. Par exemple, un traitement de texte traite les données saisies au clavier (lettres, chiffres et ponctuation) pour générer un document. Un tableur, quant à lui, saisit des nombres et calcule des sommes, des moyennes et présente ces valeurs sous forme de graphiques et de tableaux.
Un programme est conçu, écrit et testé par un programmeur. Les outils du programmeur varient selon le système d'exploitation, le langage de programmation et les outils de développement disponibles ; ils peuvent aller d'un simple éditeur de texte et d'une ligne de commande à un environnement de développement intégré (IDE) complet, doté d'une interface graphique et de fonctionnalités intégrées facilitant le travail du programmeur.
Il existe une vaste gamme de langages de programmation, allant des assembleurs capables d'écrire des programmes en code machine natif à Visual Studio de Microsoft utilisant le cadriciel .NET. Parmi les langages les plus courants, citons C/C++, BASIC, COBOL, Java, Pascal, Delphi, Fortran, ADA, Logo, Lisp, Forth et bien d'autres.
Trois composantes de la programmation
Un programme peut être écrit avec trois éléments principaux : la séquence, les décisions et les boucles.
A) Séquence
Une séquence est une suite d'instructions qui se suivent dans l'ordre. Par exemple, pour additionner deux nombres, il faut suivre les cinq étapes suivantes :
- Initialiser le total à 0.
- Ajouter 10 au total.
- Ajouter 15 au total.
- Afficher le total.
- Fin.
B) Décision
Une décision permet de tester des éléments. Par exemple, si vous comptez de 1 à 100, vous devez vérifier si vous avez atteint 100. De même, si vous disposez d'une base de données de personnes et que vous souhaitez vérifier si elles vivent à Londres, ou encore si elles sont âgées de 20 à 49 ans, une décision peut être utile. Pour utiliser les décisions, vous devez employer des opérateurs conditionnels qui comparent des valeurs. Le résultat de cette comparaison sera vrai ou faux. Voici des conditions avec leur description :
- = : égal à.
- <> : non égaux.
- < : inférieur à.
- > : supérieur à.
- <= : inférieur ou égal à.
- >= : supérieur ou égal à.
- NOT : non.
En programmation, pour prendre des décisions, on utilise l'instruction IF THEN ELSE ENDIF, par exemple :
IF age < 50 THEN
REM quelques instructions ici
ELSE
REM quelques autres instructions ici
ENDIF
|
Si la personne a moins de 50 ans, exécutez certaines instructions ; sinon, exécutez d'autres instructions. Vous pouvez placer une ou plusieurs commandes après les instructions THEN et ELSE. La partie ELSE est facultative ; vous pouvez donc simplement utiliser une instruction IF THEN ENDIF. Parfois, la commande tient sur une seule ligne, comme ceci :
IF age = 100 THEN PRINT "Vous êtes centenaire." |
Vous pouvez également combiner des conditions à l'aide d'opérateurs supplémentaires appelés opérateurs booléens, car ils produisent des valeurs vraies ou fausses. Il s'agit des opérateurs ET, OU, OU exclusif (XOR) et NON.
- x AND y : renvoie vrai si les deux conditions x et y sont vraies.
- x OR y : renvoie vrai si au moins une des conditions x ou y est vraie.
- x XOR y : OU exclusif. Renvoie vrai si une seule des conditions x ou y est vraie.
- NOT x : renvoie vrai si x est faux, ou faux si x est vrai.
IF age = 10 THEN PRINT "Vous avez 10 ans." ELSEIF age = 20 THEN PRINT "Vous avez 20 ans." ELSEIF age = 30 THEN PRINT "Vous avez 30 ans." ELSE PRINT "Vous êtes âgé"; age ENDIF |
Ici, l'âge est comparé à la valeur de la première instruction IF. En cas de correspondance, les instructions sont exécutées jusqu'à rencontrer une instruction ELSEIF IF. Si une telle instruction est trouvée, l'exécution se poursuit. Sinon, les instructions suivant l'instruction ELSE facultative sont exécutées. Une fois ces instructions terminées, le programme se poursuit après l'instruction ENDIF.
C) Boucle
La troisième structure est une boucle. Les ordinateurs excellent dans le traitement de grandes quantités de données. Pour ce faire, la boucle exécute la même série d'instructions de manière répétée. Il existe trois types de boucles :
- Boucle comptée.
- Boucle exécutée au moins une fois, dont la condition est testée à la fin.
- Boucle exécutée zéro ou plusieurs fois, dont la condition est testée au début.
FOR count = 10 TO 50 STEP 5 PRINT count NEXT count |
Le compteur de mots est une variable qui stocke la valeur du nombre et incrémente le compteur de 5 mots, de 10 à 50, par exemple : 10, 15, 20, 25, 30, 35, 40, 45 et 50. Les instructions entre les blocs FOR et NEXT sont exécutées à chaque itération de la boucle. Par défaut, la valeur de STEP est de 1.
Un autre type de boucle est la boucle while. Elle répète les instructions de la boucle tant que la condition est vraie. Par exemple :
number = 0 WHILE number <> 999 INPUT number PRINT number WEND |
Ce programme répétera les instructions entre WHILE et WEND tant que la variable "number" est différente de 999. Attention : vous devez vous assurer que "number" est égale à 999 à un moment donné pour que la boucle se termine et que les instructions se poursuivent après l'instruction de fermeture WEND ; sinon, le programme ne se terminera jamais.
3. Les structures [retour au plan]
Dans certains langages informatiques, comme le C et le C++, il est possible de regrouper des variables en structures ou classes. Une structure est un ensemble de valeurs ayant une fonction commune, comme les attributs d'une fenêtre d'ordinateur, d'un personnage de jeu vidéo, d'un client dans une base de données, d'un produit, etc. En Ace Basic, on utilise le mot-clé STRUCT. En Hisoft Basic, c'est TAGLIST. Les types de variables peuvent être combinés : une même structure peut contenir des variables de type BYTE, SHORTINT, LONGINT, ADDRESS, SINGLE et STRING (avec l'option SIZE).
Exemples
Voici la structure d'une fenêtre Amiga.
STRUCT Window SHORTINT left_position SHORTINT top_position SHORTINT width SHORTINT height STRING window_title SIZE 20 BYTE close_gadget BYTE minimize_gadget BYTE resize_gadget END STRUCT |
Voici la structure d'un dossier client.
STRUCT customer STRING customer_number SIZE 12 STRING title SIZE 4 STRING firstname SIZE 20 STRING lastname SIZE 20 STRING street SIZE 20 STRING city SIZE 20 STRING county SIZE 20 STRING country SIZE 20 STRING postcode SIZE 10 STRING telephone_number SIZE 20 SINGLE balance END STRUCT |
Pour utiliser une instance d'une structure, vous spécifiez le mot-clé DECLARE STRUCT, le nom de la structure et le nom de la variable, par exemple :
DECLARE STRUCT customer customer1 |
Pour utiliser les valeurs individuelles d'une structure, vous utiliserez le format variable->nom_du_champ, où un tiret et une flèche vers la droite séparent la variable et le nom du champ, par exemple : client1.street.
Par exemple :
Customer1->customer_number = "100101" customer1->title = "Mr" customer1->firstname = "Simon" etc. |
4. Les sous-routines [retour au plan]
Les programmes peuvent devenir très volumineux à mesure que l'on ajoute des lignes d'instructions. De plus, il arrive qu'on ait besoin de réutiliser des portions de code. C'est là qu'interviennent les sous-routines et les fonctions.
Une sous-routine est un ensemble d'instructions qui exécute une tâche spécifique. Par exemple, une sous-routine peut calculer la moyenne d'un tableau de nombres et afficher le résultat. Une sous-routine possède toujours un nom et reçoit parfois une liste de valeurs (appelées "paramètres") qu'elle peut utiliser ; ici, un tableau et le nombre d'éléments qu'il contient (appelé "num"). Une sous-routine ne renvoie jamais de valeur. Nous utiliserons une boucle "for", qui parcourra le tableau de 1 à "num" et utilisera une variable "sum" pour stocker la somme des valeurs et une autre variable "avg" pour stocker la moyenne. La commande "print" affichera le résultat à l'écran.
Par exemple :
SUB average ( numbers(), num) sum = 0 ' Mettre la somme des nombres à zéro FOR n=1 TO num ' Compter de 1 à num, et incrémenter count de 1 sum = sum + numbers(n) NEXT N avg = sum / num PRINT "La moyenne est ";avg END SUB |
Pour utiliser cette sous-routine, vous pouvez l'appeler depuis le programme principal ou même d'autres sous-routines, en utilisant son nom et en lui passant les variables ou les valeurs dont elle a besoin.
Par exemple :
DIM numbers(5) ' Définir un tableau de cinq entiers, dont un pour l'indice 0 numbers(1) = 456 numbers(2) = 172 numbers(3) = 78 numbers(4) = 102 numbers(5) = 321 CALL average( numbers(), 5) |
...devrait afficher le résultat suivant :
La moyenne est de 225,8 |
L'ancienne méthode pour appeler des sous-routines consiste à utiliser l'étiquette GOSUB ou le numéro de ligne, puis à utiliser l'instruction RETURN pour revenir au programme principal.
Par exemple :
... GOSUB CalcAvg PRINT average ... END CalcAvg: average = total / num RETURN |
Fonctions
Une fonction est très similaire à une sous-routine : il s'agit toujours d'un ensemble d'instructions qui effectue une tâche spécifique, mais cette fois-ci, elle renvoie une valeur. Le type de cette valeur est spécifié par le type de la variable, par exemple LONGINT, ADDRESS, SHORTINT, SINGLE ou STRING. Pour renvoyer une valeur, il suffit d'assigner une valeur au nom de la fonction. La fonction peut ensuite être utilisée dans des expressions. Ainsi, si vous devez effectuer régulièrement des calculs complexes, vous pouvez créer une fonction et l'utiliser dans des expressions et des affectations.
Par exemple :
SUB SINGLE Average (numbers(), num) ' La fonction s'appelle average et renvoie un nombre à virgule flottante sum = 0 ' Initialiser la somme des nombres à zéro FOR n=1 TO num sum = sum + numbers(n) NEXT n avg = sum / num; Average = avg ' Affecter la valeur de retour au nom de la fonction END SUB |
Vous pouvez maintenant l'utiliser dans des expressions ou des affectations du programme principal, des sous-routines ou même d'autres fonctions.
Par exemple :
MyAverage = Average(numbers(), 5) PRINT "La moyenne est "; MyAverage |
De nombreux langages de programmation intègrent des bibliothèques de fonctions utilisables dans vos programmes. Certaines fonctions effectuent des calculs arithmétiques complexes, comme la racine carrée, les sinus, les cosinus, les tangentes, et le calcul des valeurs minimales et maximales. D'autres permettent de manipuler les chaînes de caractères : calcul de la longueur, extraction de sous-chaînes, concaténation, etc.
5. Entrées et sorties [retour au plan]
Pour qu'un programme soit vraiment utile, il doit pouvoir recevoir des données saisies par l'utilisateur et afficher les résultats. Ces données peuvent provenir du clavier et s'afficher à l'écran. Dans les programmes simples, on utilise l'interpréteur de commandes (ou Shell) pour la saisie et l'affichage. On parle alors d'entrées et de sorties standard.
A) Entrée
Lors de la saisie de données, il est nécessaire de parcourir le clavier à la recherche de caractères et de les stocker dans un tampon ou une variable. En BASIC, la commande est INPUT ["invite";] variable. La commande INPUT affiche l'invite (facultative) et demande une saisie, puis stocke le contenu dans la variable.
Exemple de code d'entrée :
INPUT "Entrez votre nom? "; name$ INPUT "Entrez un nombre (1 to 100)? "; number |
Si vous utilisez une interface graphique, la saisie se fera via des zones de texte, des boutons et des boîtes de dialogue permettant de saisir du texte, des nombres, de faire des sélections ou de répondre aux questions du programme. Sous AmigaBASIC, cela se fait à l'aide de commandes telles que WINDOW, GADGET, etc.
Par exemple, un gadget de saisie de chaînes de caractères peut être créé dans une fenêtre précédemment ouverte :
- GADGET 1,1,"",(50,20)-(150,30),2 ' crée un gadget de saisie de chaînes de caractères (l'identifiant est 1).
- GADGET OUTPUT 1 ' définit le gadget courant sur l'identifiant 1.
- value$ = GADGET (2) ' renvoie la valeur de ce gadget.
B) Sortie
Pour afficher des données ou des informations, on utilise généralement l'interpréteur de commandes. En BASIC, la commande est PRINT expression-list. Cette liste peut contenir des chaînes de caractères, des nombres et des variables. Les données peuvent être séparées par un point-virgule (;), qui affiche l'avant-dernier élément, ou par une virgule (,), qui sépare les données par une tabulation jusqu'à la prochaine virgule (définie par l'instruction WIDTH).
Par exemple
PRINT "Entrez votre nom:" ' affiche le texte 'Entrez votre nom:' PRINT "Le résultat est "; result ' affiche le texte 'Le résultat est ' suivi d'un nombre décimal provenant de la variable appelée result PRINT "Votre nom est ";name;" et votre âge est "; age ' affiche le texte 'Votre âge est ' et le contenu de la variable name suivi du texte ' et votre age est ', puis le contenu de la variable décimale */ PRINT A, B, C, TOTAL |
Vous pouvez également spécifier l'emplacement de l'affichage dans une fenêtre à l'aide de l'instruction LOCATE. Le format est LOCATE ligne, colonne.
LOCATE 20,1 PRINT "Score "; sc |
Si vous souhaitez formater vos informations, vous pouvez utiliser les fonctions SPC et TAB. SPC(n) affichera "n" espaces, tandis que TAB(n) organisera vos données en colonnes ordonnées, "n" spécifiant la prochaine colonne de tabulation.
Par exemple
PRINT A; TAB(10); B; TAB(20); C; TAB(30); TOTAL |
Un affichage plus avancé est possible avec PRINT USING format-string; string-expression. La chaîne de format détermine la largeur exacte, le type de caractères et leur position : dièse (#) pour les chiffres, point (.) pour les décimales, plus et moins (+/-) pour le symbole numérique, dollar ($) pour les devises, astérisque (*) pour les espaces en début de ligne, tiret (-) pour les caractères littéraux et accent circonflexe (^) pour les exposants. Exemple :
PRINT USING "+###.##"; 200.45, 17.6, 197.04, -26.0 |
Si vous utilisez une interface graphique, l'affichage se fera via des étiquettes ou des zones de texte, permettant d'afficher du texte ou des nombres. Sous AmigaBASIC, cela se fait grâce à des commandes telles que WINDOW, GADGET, etc.
Par exemple, pour afficher du texte dans un gadget :
GADGET 4,1,"Veuillez saisir votre nom ici",(50,20)-(150,30),2,1 ' Crée un gadget de chaîne (l'identifiant est 4). |
De plus, au lieu de simplement du texte, des nombres ou une liste de nombres, vous pouvez également afficher des résultats sur des formulaires et utiliser des graphiques et des diagrammes à l'aide des outils de dessin fournis en BASIC à l'aide de commandes telles que LINE, CIRCLE, AREA et AREAFILL.
6. Ouverture d'un écran [retour au plan]
AmigaOS gère le concept d'écrans, qui correspond à une configuration d'affichage avec une résolution et une profondeur de couleur spécifiques, limitées par les pilotes du moniteur et le type d'écran (CRT ou LCD) utilisé. Sur les Amiga classiques, on peut utiliser des résolutions basses ou moyennes avec des profondeurs de couleur de 4 à 256 couleurs. Les Amiga équipés d'une carte graphique peuvent gérer des résolutions plus élevées, avec 65 000 ou 16 millions de couleurs, voire plus, grâce aux bibliothèques Picasso96 ou CyberGraphX. Les écrans font partie de la bibliothèque Intuition.
Si vous ne souhaitez pas ouvrir un nouvel écran, vous pouvez lancer une application sur l'écran Workbench par défaut. Cet écran, dit "public", permet d'exécuter plusieurs applications simultanément.
Un écran est utile si vous souhaitez utiliser une résolution et une profondeur de couleur spécifiques pour votre application ; les jeux utilisent généralement leurs propres écrans adaptés à leurs besoins.
Plusieurs fonctions permettent d'ouvrir un écran :
- SCREEN : ouvre un écran.
- SCREEN(n) : affiche des informations sur un écran.
- SCREEN BACK n : place un écran au second plan.
- SCREEN FORWARD n : place un écran au premier plan.
- SCREEN CLOSE n : ferme un écran.
Cette commande vous permet de créer un nouvel écran pour votre application. Le format de la commande est :
SCREEN screen-id, width, height, depth, mode |
...où :
- screen-id : 1 à 255.
- width : largeur de l'écran en pixels, par exemple 320, 640, etc.
- height : hauteur de l'écran en pixels, par exemple 200, 256, 512.
- depth : nombre de plans de couleur (1 à 8). Nombre de couleurs = 2^depth.
- mode : mode d'écran (1 à 6).
- 1 : basse résolution (lores).
- 2 : haute résolution (hires).
- 3 : basse résolution entrelacée.
- 4 : haute résolution entrelacée.
- 5 : HAM (hold and modify), sur ACE Basic uniquement.
- 6 : Extra Half-Brite, sur ACE Basic uniquement.
SCREEN 1,640, 480, 8, 4 SLEEP FOR 30 ' attend pendant 30 secondes SCREEN CLOSE 1 END Utilisation de la fonction SCREEN
Dans ACE Basic, la fonction SCREEN suivante fournit les informations suivantes concernant l'écran actuel :
- SCREEN(0) = renvoie l'adresse du pointeur vers la fenêtre Intuition.
- SCREEN(1) = renvoie l'adresse du pointeur vers l'écran Intuition.
- SCREEN(2) = renvoie le pointeur vers la zone rastport de la fenêtre par défaut ou de la fenêtre courante.
- SCREEN(3) = renvoie le pointeur vers la zone d'affichage de l'écran.
- SCREEN(4) = renvoie le pointeur vers l'image bitmap de l'écran.
- SCREEN(5) = renvoie la largeur de la police de l'écran.
- SCREEN(6) = renvoie la hauteur de la police de l'écran.
- CLS : efface la fenêtre ou l'écran courant.
- CSRLIN : renvoie la ligne d'affichage de la fenêtre ou de l'écran utilisateur courant.
- PALETTE : modifie la couleur de la palette à l'aide des valeurs RVB.
L'étape suivante consiste à ouvrir une fenêtre. Vous pouvez l'ouvrir sur un écran public, comme l'espace de travail, ou sur un écran personnalisé créé précédemment. Vous pouvez créer autant de fenêtres que vous le souhaitez et les placer où bon vous semble. Chaque fenêtre peut comporter des boutons système de base tels que fermer la fenêtre, agrandir/réduire la fenêtre, déplacer la fenêtre au premier plan/arrière-plan ou redimensionner la fenêtre. Un emplacement est prévu pour le titre de la fenêtre en haut. Lorsqu'un utilisateur clique sur une fenêtre ou un bouton, un événement ou un message est généré et peut être traité par votre programme.
Pour ouvrir une fenêtre à l'aide de la commande WINDOW, le format est le suivant :
WINDOW id,[title-string],(x1,y1)-(x2,y2)[,type][,screen-id] |
Les paramètres sont les suivants :
- id : identifiant de la fenêtre (1-n).
- title-string : nom facultatif de la fenêtre à afficher dans la barre de titre.
- Position et coordonnates : spécifie les coordonnées du bord supérieur gauche et du bord inférieur droit (en pixels).
- Type : options de configuration de la fenêtre. La valeur par défaut est 31.
- Screen-id : identifiant facultatif d'un écran personnalisé.
- 1 : la taille de la fenêtre peut être modifiée à l'aide du gadget de redimensionnement.
- 2 : la fenêtre peut être déplacée à l'aide de la barre de titre.
- 4 : la fenêtre peut être déplacée du premier plan vers l'arrière-plan à l'aide du gadget "Back" (Arrière).
- 5 : ajout du gadget "Zoom" (AmigaOS 2.x ou version ultérieure).
- 8 : ajout du gadget "Close" (Fermer).
- 16 : le contenu de la fenêtre réapparaît après avoir été masqué.
- 32 : la fenêtre est sans bordure.
WINDOW 1, "Ma fenêtre", (20,20)-(220,170), 31 SLEEP FOR 30 ' Attend 30 secondes WINDOW CLOSE 1 END |
Autres instructions et fonctions de fenêtre
- WINDOW(n) : fonction renvoyant des informations sur une fenêtre (ACE Basic).
- WINDOW CLOSE n : ferme une fenêtre.
- WINDOW ON | OFF | STOP : active, désactive ou suspend une fenêtre.
- WINDOW OUTPUT n : définit une fenêtre comme fenêtre active.
- Instruction ON WINDOW : interception d'événements de fenêtre, comme le gadget de fermeture.
Pour qu'AmigaOS puisse traiter des événements tels que la fermeture d'une fenêtre ou la sélection d'un gadget, le BASIC doit détecter et traiter ces événements. Ceci peut être réalisé grâce à la capture d'événements via l'instruction ON <type-événement>. Par exemple : ON WINDOW, ON GADGET, ON MOUSE, ON MENU, ON ERROR, ON TIMER et ON BREAK.
L'exemple suivant ferme la fenêtre si le gadget "Close" (Fermer) a été pressé (au lieu d'un délai comme dans les exemples précédents) :
ON WINDOW GOTO Quit WINDOW 1, "Ma fenêtre", (20,20)-(220,170), 31 WINDOW ON ' active la gestion des fenêtres et des événements WHILE -1 SLEEP ' attend indéfiniment ou qu'un événement se produise WEND Quit: WINDOW CLOSE 1 END |
S'il y a de nombreux types d'événements à sélectionner (gadgets, mouvements de souris, frappes au clavier, changements de fenêtre, etc.), une instruction "select" est plus appropriée qu'une instruction "if". En fait, il serait préférable de placer ce code dans une fonction distincte, à appeler en cas de besoin.
8. Définition des menus [retour au plan]
AmigaOS gère les menus accessibles via la barre de titre en haut de l'écran. Ces menus peuvent comporter plusieurs en-têtes (Fichier, Édition, Icônes, Fenêtres, Options, etc.) et, sous chaque en-tête, des sous-éléments tels que Ouvrir, Enregistrer, Enregistrer sous, Fermer et Quitter. Il est possible de cocher ces sous-éléments, de leur attribuer des images et des raccourcis clavier. Pour utiliser un menu, il faut utiliser l'instruction "menu" et l'associer à une fenêtre.
Le format des instructions du menu est le suivant :
MENU menu-id, item-id, state [,title [,command-key]] |
Elle présente les arguments suivants :
- menu-id : numéro de 1 à 10.
- item-id : numéro de l'élément (item) de 0 à 19, où 0 correspond au niveau supérieur du menu et 1 à 19 à un sous-élément.
- state : 0 pour désactivé, 1 pour activé et 2 pour activé et coché.
- title : texte à afficher pour le menu ou l'élément de menu.
- command-key : touche de raccourci pour l'élément de menu.
- MENU (n) : renvoie des informations sur l'élément de menu le plus récemment sélectionné. 0 : numéro du menu, 1 : numéro de l'élément de menu, 2 : numéro du sous-élément de menu.
- MENU CLEAR or MENU RESET : efface tous les menus de la fenêtre actuelle.
- MENU ON | OFF | STOP : active, désactive ou suspend la capture des événements de menu.
- MENU WAIT : suspend le programme et attend toute activité du menu.
- Instruction ON MENU : indique l'instruction à exécuter lorsqu'un événement de menu se produit.
REM ** Exemple de menu ** WINDOW 1, "Ma fenêtre", (20,20)-(220,170), 31 REM Menu principal (menu 1) MENU 1, 0 ,1,"Fichier" REM Sous-élément du menu 1 MENU 1, 1, 1, "Ouvrir" MENU 1, 2, 1, "Sauvegarder" MENU 1, 3, 1, "Imprimer" MENU 1, 4, 1, "Quitter" REM Activer la capture d'événement ON MENU GOSUB HandleMenu MENU ON done = -1 REM Boucle principal. Attend un événement de menu WHILE done = -1 MENU WAIT WEND MENU CLEAR WINDOW CLOSE 1 END |
HandleMenu :
IF MENU(0) = 1 THEN IF MENU(1) = 1 THEN REM Ouvrir un fichier ELSEIF MENU(1) = 2 THEN REM Sauver un fichier ELSEIF MENU(1) = 3 THEN REM Imprimer un fichier ELSEIF MENU(1) = 4 THEN done = 0 ENDIF ENDIF RETURN |
9. Gadgets [retour au plan]
Intuition dans AmigaOS 1.x proposait des gadgets, mais ceux-ci étaient plats et plutôt ternes. C'est pourquoi, avec AmigaOS 2, la bibliothèque Gadtools a été introduite pour moderniser les gadgets et leur permettre d'utiliser un style 3D plus attrayant, nettement supérieur à celui d'Intuition. Les fenêtres intègrent des gadgets système tels que la fermeture de fenêtre, le bouton avant/arrière, le redimensionnement, etc. Vous pouvez définir vos propres gadgets à l'aide de l'instruction GADGET.
GADGET id, status [,gadval, rectangle, type [,style] [,font, size, textstyle]] |
...où les arguments sont les suivants :
- id : identifiant du gadget (de 1 à 255).
- status : active (1) ou désactive (0) le gadget.
- gadval : chaîne de caractères ou entier long selon le type de gadget.
- rectangle : position et taille du gadget au format (x1, y1)-(x2, y2).
- type : type de gadget : booléen ou bouton (1), chaîne de caractères (2), entier long (3), curseur horizontal (4) ou curseur vertical (5). Ou utilisez les mots-clés BUTTON, STRING, LONGINT, POTX, POTY.
- style : valeur de 1 à 3 déterminant le style du gadget (par exemple, justifié ou sans bordure).
- font : nom de la police.
- size : taille de la police.
- textstyle : gras, souligné, italique, etc.
- GADGET(n) : renvoie des informations sur un gadget (n = 0 à 4).
- GADGET CLOSE id : supprime le gadget de la fenêtre active.
- GADGET MOD id, pos, max-pos : modifie les valeurs proportionnelles des gadgets à curseur.
- GADGET ON | OFF | STOP : active, désactive ou suspend la capture d'événements d?un gadget.
- GADGET OUTPUT id : définit le gadget actif pour la collecte d'informations.
- GADGET WAIT id : met le programme en veille jusqu'à la survenue d'un événement.
- Instruction ON GADGET : capture d'événements de gadget.
WINDOW 1, "Ma fenêtre", (10,15)-(290,195), 31 ON WINDOW GOSUB HandleWindow WINDOW ON ' Définir la police FONT "topaz", 8 ' Gadget de chaîne LOCATE 4,1 PRINT "Nom" GADGET 1, 1, "", (63,26)-(239,46), STRING ' Gadget entier LOCATE 7,1 PRINT "Age" GADGET 2, 1, "0", (62,50)-(239,70), LONGINT ' Boutton ou gadget booléen GADGET 3, 1, "Calc", (111,105)-(165,136), BUTTON ON GADGET GOSUB HandleGadget GADGET ON done = -1 WHILE done = -1 SLEEP WEND WINDOW CLOSE 1 END |
HandleWindow :
done = 0 RETURN |
HandleGadget :
' Détermine quel gadget a été pressé gadno=GADGET(0) RETURN |
10. Graphismes linéaires [retour au plan]
Il est possible de réaliser des graphismes linéaires classiques sur Amiga en utilisant le langage BASIC. Des centaines de fonctions sont disponibles : choix des couleurs, tracé de lignes, de rectangles, de cercles, de motifs, remplissage de zones, etc. Pour utiliser ces fonctions, vous devez ouvrir une fenêtre contenant une zone bitmap adaptée au dessin.
Commandes de graphismes linéaires simples
Les commandes suivantes permettent de réaliser des tracés simples sur une zone rastport spécifique d'une fenêtre ou d'un calque. Par exemple :
- COLOR foreground, background : définit la couleur de premier plan ou d'arrière-plan à l'aide de stylos de couleur prédéfinis.
- PALETTE id, red, green, blue : modifie la couleur à l'aide des valeurs RVB (0,0 à 1,0) associées à un identifiant de couleur.
- PSET [STEP] (x, y) [, colour-id] : place un point aux coordonnées x,y en utilisant la couleur (ou la couleur de premier plan actuelle). STEP indique la position relative.
- LINE [STEP] (x1,y1) [-(x2,y2) [,[colour] [,b[f]]]] : trace une ligne de x1,y1 à x2,y2 ou, si seuls x,y sont fournis, trace une ligne de la dernière position à x,y dans la couleur spécifiée.
- CIRCLE (x,y), radius [,colour, start, end, aspect] : trace un cercle ou une ellipse aux coordonnées x,y avec un rayon. Début et fin spécifient les angles en degrés. L'aspect est de 0,44 par défaut.
- POINT(x,y) : lit le point de coordonnées x,y et renvoie son identifiant de couleur.
RANDOMIZE TIMER ON WINDOW GOTO Quit WINDOW 1, "Ma fenêtre", (20,20)-(220,170), 31 WINDOW ON ' Dessine des carrés aléatoires dans la fenêtre FOR n = 1 TO 10 COLOR RND*32, 1 ' Couleur aléatoire 0-32 startx = 10 + RND*50 starty = 10 +RND*50 boxwidth = 20 + RND*50 LINE (startx, starty)-(startx+boxwidth, starty) LINE (startx+boxwidth, starty)-(startx+boxwidth, starty+boxwidth) LINE (startx+boxwidth, starty+boxwidth)-(startx, starty+boxwidth) LINE (startx, starty+boxwidth)-(startx, starty) NEXT n WHILE -1 SLEEP ' Attendre indéfiniment ou qu'un événement se produise WEND Quit: WINDOW CLOSE 1 END |
Une nouvelle fonction appelée RND génère un nombre aléatoire entre 0 et 1. En multipliant ce nombre par un autre, on obtient un nombre compris entre 0 et ce multiplicateur. Par exemple, RND*50 générera un nombre entre 0 et 50. Pour éviter que les mêmes nombres aléatoires ne soient générés à chaque exécution du programme, la commande RANDOMIZE TIMER est utilisée pour initialiser la fonction TIMER. Vous pouvez utiliser la fonction INT (entier) pour arrondir la valeur à l'entier le plus proche, par exemple INT(50*RND+1).
J'ai dû définir une position de départ pour éviter que les bordures de la fenêtre ne soient écrasées, puis utiliser des valeurs aléatoires pour générer une position de départ aléatoire en haut à gauche du carré et une taille aléatoire pour le dessiner. Les valeurs de LINE sont des positions absolues et non relatives ; j'ai utilisé startx + valeur et starty + valeur pour faciliter le dessin du carré. Une fois la boucle de dessin terminée, le programme attend que l'utilisateur sélectionne le gadget de fermeture de la fenêtre, puis se termine normalement.
Dessiner avec des aires
Il est possible de créer des zones polygonales remplies à l'aide des instructions AREA et AREAFILL, qui permettent de tracer le contour d'une forme et de la remplir avec une couleur spécifiée. La syntaxe de ces fonctions est la suivante :
- AREA [STEP] (x, y)
- AREAFILL [mode]
- PATTERN [line-pattern] [, area-pattern] | RESTORE
- PAINT (x,y) [[, color-id] [, border-id]]
L'instruction PATTERN définit le motif de remplissage des lignes et des zones. Le motif de ligne est un entier court, tandis que le motif de zone est un tableau d'entiers courts. Le nombre d'éléments doit être une puissance de 2 (par exemple : 2, 4, 8, 16, 32, etc.). L'option RESTORE (en ACE Basic uniquement) rétablit les valeurs par défaut des motifs.
La commande PAINT permet de remplir une zone fermée avec une couleur spécifiée, jusqu'aux bords indiqués par l'identifiant de couleur (colour-id). Il est également possible de spécifier une couleur différente pour la bordure à l'aide de l'option "border-id". Les coordonnées x et y peuvent se situer n'importe où dans la zone.
L'exemple ci-dessous dessine un couloir simple à l'aide de zones remplies :
RANDOMIZE TIMER ON WINDOW GOTO Quit WINDOW 1, "Ma fenêtre", (20,20)-(220,170), 30 WINDOW ON ' Crée un couloir avec des zones COLOR 3,1 AREA (90,12) AREA (90,40) AREA (30,135) AREA (30, 75) AREAFILL 0 COLOR 6,1 AREA (4,75) AREA (30, 75) AREA (30, 135) AREA (4, 135) AREAFILL 0 COLOR 3,1 AREA (110, 12) AREA (170,75) AREA (170, 135) AREA (110, 40) AREAFILL 0 COLOR 6,1 AREA (170, 75) AREA (195, 75) AREA (195, 135) AREA (170, 135) AREAFILL 0 COLOR 1,1 LINE (90, 40)-(110, 40) LINE (30, 135)-(170, 135) WHILE -1 SLEEP ' Attendre indéfiniment ou qu'un événement se produise WEND |
Quit :
WINDOW CLOSE 1 END |
11. Sprites et BOB [retour au plan]
AmigaBASIC et HiSoft Basic gèrent les sprites et les BOB (Blitter Objects) pour l'animation. AmigaBASIC peut gérer plusieurs sprites, dans la limite de la mémoire disponible. ACE Basic ne possède aucune fonctionnalité de sprites/BOB ; vous devrez donc utiliser les fonctionnalités de la bibliothèque graphics library.
Pour utiliser des sprites et des BOB, vous devez utiliser les instructions OBJECT pour les créer et les manipuler :
- OBJECT.SHAPE id, definition : crée et définit la forme d'un objet (id peut être compris entre 1 et n).
- OBJECT.SHAPE id1, id2 : copie un objet vers un autre.
- OBJECT.START id[,id2...] : démarre le mouvement des objets.
- OBJECT.STOP id [id2...] : arrête ou fige le mouvement des objets.
- OBJECT.VX id, value : spécifie la vitesse de l'objet selon l'axe x (horizontal). La vitesse est exprimée en pixels/seconde.
- OBJECT.VY id, value : spécifie la vitesse de l'objet selon l'axe y (vertical). La vitesse est exprimée en pixels/seconde.
- OBJECT.VX (id) : renvoie la vitesse de l'objet selon l'axe x.
- OBJECT.VY (id) : renvoie la vitesse de l'objet selon l'axe y.
- OBJECT.X id, value : spécifie les coordonnées x de l'objet.
- OBJECT.Y id, value : spécifie les coordonnées y de l'objet.
- OBJECT.X (id) : renvoie la coordonnée x de l'objet.
- OBJECT.Y (id) : renvoie la coordonnée y de l'objet.
- OBJECT.AX id, value : spécifie l'accélération axiale de l'objet selon l'axe x.
- OBJECT.AY id, value : spécifie l'accélération axiale de l'objet selon l'axe y.
- OBJECT.CLIP (x1, y1)-(x2, y2) : définit un rectangle et indique au BASIC de ne pas dessiner d'objets en dehors de cette zone.
- OBJECT.CLOSE [id] [,id2 ...] : supprime un ou plusieurs objets de la mémoire.
- OBJECT.HIT id [,MeMask] [,HitMast] : détermine les masques de la source et de l'objet à toucher.
- OBJECT.ON [id [, id2 ...] : active les objets (les rend visibles).
- OBJECT.OFF [id [id2 ...] : désactive les objets (les rend invisibles).
- OBJECT.PLANES id [, plane-pick][, plane-on-off] : définit les valeurs de sélection et d'activation/désactivation des plans d'un objet (0-255).
- OBJECT.PRIORITY id, value : détermine la priorité d'affichage de l'objet par rapport aux autres objets (objets). Valeur comprise entre -32768 et 32767.
- COLLISION(id) : renvoie l'identifiant de l'objet ou la valeur de sa bordure (-1 à -4) en cas de collision.
- COLLISION ON|OFF|STOP : active, désactive ou suspend la détection des collisions.
Pour créer un sprite ou un BOB en BASIC, utilisez la commande OBJECT.SHAPE. Vous pouvez fournir un numéro d'identification pour chaque objet, ainsi qu'une chaîne de caractères définissant sa forme et sa couleur. Pour faciliter la définition de vos objets, AmigaBASIC propose un éditeur d'objets qui génère automatiquement une définition. Il est conseillé d'exécuter l'éditeur en mode basse résolution pour travailler plus facilement sur les petits sprites ou BOB. Vous pouvez ensuite charger la forme depuis un fichier dans votre programme.
Par exemple :
OPEN "sprite.dat" FOR INPUT AS 1 OBJECT.SHAPE 1, INPUT$(LOF(1), 1) CLOSE 1 |
Détection de collision
Pour déterminer si des sprites entrent en collision, vous devez utiliser des commandes telles que OBJECT.HIT, ON COLLISION GOSUB, COLLISION ON|OFF|STOP et la fonction COLLISION. L'instruction Object.Hit définit les masques de l'objet source et de l'objet à heurter afin de déterminer si une collision a eu lieu. Par exemple, vous ne voulez pas qu'un objet heurte une zone rectangulaire s'il s'agit en réalité d'une sphère. Il est donc nécessaire de configurer des masques pour définir la zone à heurter. L'instruction ON COLLISION GOSUB indique au système où effectuer un saut en cas de collision ; il suffit de fournir une étiquette ("label") à la ligne de destination.
La fonction Collision(n) renvoie soit l'identifiant de l'objet heurté, soit l'un des quatre bords de la fenêtre. Si n=0, elle renvoie l'identifiant de l'objet entré en collision avec un autre. Si n=-1, elle renvoie l'identifiant de la fenêtre dans laquelle la collision a eu lieu. Si n>0, elle renvoie l'identifiant de l'objet heurté. Une valeur négative indique que l'objet est entré en collision avec un bord de la fenêtre : -1=bord supérieur, -2=bord gauche, -3=bord inférieur et -4=bord droit.
Exemple d'animation
WINDOW 1,"Animation", (10,10)-(270,70),15 WINDOW 1 LOCATE 4,4 COLOR 3,2 PRINT "Amiga Microsoft Basic" COLOR 1,0 ON COLLISION GOSUB bounceoff COLLISION ON REM Ouvrir l'objet balle à partir d'un fichier OPEN "balle" FOR INPUT AS 1 OBJECT.SHAPE 1,INPUT$(LOF(1),1) CLOSE 1 REM Definit la position et les vitesses de départ OBJECT.X 1,60 OBJECT.Y 1,50 OBJECT.VX 1,80 OBJECT.VY 1,80 REM Copie l'objet 1 et le configure également OBJECT.SHAPE 2,1 OBJECT.X 2,50 OBJECT,Y 2,10 OBJECT.VX 2,40 OBJECT.VY 2,40 OBJECT.ON OBJECT.START WHILE 1 SLEEP WEND END |
Bounceoff :
SAVEID = WINDOW(1) WINDOW OUTPUT 1 IF WINDOW(7)=0 THEN RETURN COUNTDOWN=COUNTDOWN-1 IF COUNTDOWN<0 THEN COUNTDOWN=10 OBJECT.CLIP (0,0)-(WINDOW(2), WINDOW(3)) END IF |
Bounceloop :
REM Si l'objet heurte les bords ou un autre objet, change de direction I=COLLISION(0) IF I=0 THEN BOUNCEEXIT J=COLLISION(I) VXI = OBJECT.VX(I) VYI = OBJECT.VY(I) IF (J=-1 AND VYI<0) OR (J=3 AND VYI>0) THEN OBJECT.VY I,-VYI ELSEIF (J=-2 AND VXI<0) OR (J=-4 AND VXI>0) THEN OBJECT.VX I,-VXI ELSEIF J>0 THEN VYJ = OBJECT.VY(J) VXJ = OBJECT.VX(J) ENDIF IF VYI*VYJ<0 THEN OBJECT.VY I,-VYI OBJECT.VY J,-VYJ END IF IF VXI*VXJ<0 THEN OBJECT.VX I,-VXI OBJECT.VX J,-VXJ END IF OBJECT.START J END IF OBJECT.START I GOTO BOUNCELOOP |
Bounceexit :
WINDOW OUTPUT SAVEID RETURN |
12. Entrée et sortie de fichiers [retour au plan]
AmigaBASIC inclut des fonctions de fichiers simples pour ouvrir, lire, écrire et fermer des fichiers. Les instructions suivantes sont couramment utilisées :
- OPEN "filename" [FOR INPUT | OUTPUT | APPEND] AS filenumber
- OPEN mode, [#] filenumber, filename [,file-buffer-size]
- CLOSE [#]filenumber[ , ...]
- EOF(filenumber)
- INPUT$(x [,[#] filenumber)
- INPUT #filenumber, variable-list
- WRITE #filenumber, expression-list
- PRINT #filenumber, [USING string-expr;] expression-list
- GET [#]filenumber,][,recordnumber]
- PUT [#]filenumber [,recordnumber]
- FIELD [#]filenumber, fieldwidth AS string-variable, ...
- LSET string-variable=string-expression
- RSET string-variable=string-expression
Les instructions Get, Put, Field, Lset et Rset ne peuvent être utilisées que pour les fichiers à accès aléatoire. La largeur du champ ("fieldwidth") pour l'instruction FIELD peut être inférieure ou égale à la taille du tampon spécifiée dans l'instruction OPEN. Les variables LSET et RSET ne doivent être utilisées qu'avec les entrées/sorties de fichiers et jamais avec les instructions LET ou INPUT.
Entrée et sortie de fichiers séquentiels
Pour les fichiers séquentiels, utilisez les modes INPUT, OUTPUT ou APPEND de l'instruction OPEN. La différence entre OUTPUT et APPEND réside dans le fait que OUTPUT crée un nouveau fichier s'il n'existe pas et écrase son contenu s'il existe déjà. APPEND ajoute systématiquement les nouvelles données à la fin du fichier existant. L'exemple suivant écrit 20 nombres dans un fichier, puis les relit et les affiche dans la console.
REM Exemple de fichier REM par P Hutchison PRINT "Écrit des nombres dans numbers.dat." REM Ouverture du fichier pour écriture OPEN "numbers.dat" FOR OUTPUT AS 1 FOR n=1 to 20 PRINT #1, n NEXT n CLOSE 1 REM Lit les nombres depuis un fichier PRINT "Lecture du fichier numbers.dat." REM Ouvre le fichier existant pour lecture OPEN "numbers.dat" FOR INPUT AS 1 WHILE NOT EOF(1) INPUT #1, num PRINT "Number ";num WEND CLOSE 1 END |
Entrée et sortie de fichiers aléatoires
Voici un exemple de sélection aléatoire d'enregistrements dans un fichier de base de données clients.
REM Lire les enregistrements d'une base de données clients OPEN "customers.dat" AS 1 LEN = 155 REM Numéro de client, prénom, nom, adresse, téléphone FIELD 1, C$ AS 10, 25 AS f$, 25 AS l$, A$ AS 100, T$ AS 20 RECNO = 1 WHILE RECNO>0 INPUT "Numéro d'enregistrement ?";RECNO GET #1, RECNO PRINT "Numéro de client: "; C$ PRINT "Prénom: "; F$ PRINT "Nom: "; L$ PRINT "Adresse: " ' A$ PRINT "Téléphone: "; T$ PRINT " " WEND END |
13. Son [retour au plan]
L'Amiga est équipé d'une puce sonore dédiée, Paula, programmable via le périphérique audio.device. Pour générer du son, ouvrez ce périphérique, configurez les paramètres et envoyez les données audio brutes à la puce. Si le son est dans un format spécifique (8SVX, MUS, WAV, etc.), les données doivent être extraites des fichiers puis envoyées au périphérique audio. Ce processus peut s'avérer complexe, mais l'utilisation de datatypes permet de réduire considérablement le code nécessaire à la production du son. Les données sonores doivent être stockées dans la mémoire Chip pour être lues, ce qui limite la taille du fichier audio, sauf si des techniques de mise en mémoire tampon sont mises en oeuvre.
Lecture du son
- BEEP
- SOUND freqency, duration [, [volume] [,voice]]
- SOUND WAIT
- SOUND RESUME
- WAVE voice, wave-definition
Cet exemple joue une note La à 440 Hz pendant environ une seconde, à un volume de 20 et sur le canal 0. Exemple : SOUND 440,20,100,0. L'instruction WAVE peut étendre les possibilités de l'instruction SOUND en utilisant un tableau de nombres pour définir la forme du son. La voix correspond au numéro du canal (de 0 à 3) et la définition de l'onde peut être le mot-clé SIN pour une onde sinusoïdale ou un tableau d'au moins 256 valeurs comprises entre 128 et 127. Par exemple : WAVE 0, SIN.
Synthèse vocale
AmigaOS 1.3 inclut une bibliothèque de traduction pour la synthèse vocale qui peut être utilisée pour vous parler avec une voix masculine, féminine ou robotique.
- SAY "string" [,mode-array]
- TRANSLATE$("string")
14. Ouverture d'une bibliothèque [retour au plan]
Pour accéder aux bibliothèques partagées, vous devez d'abord les ouvrir avant de pouvoir utiliser les fonctions qu'elles proposent. Cela se fait à l'aide de la commande LIBRARY, qui est une fonction de l'exec.library. La bibliothèque exec.library est la seule toujours ouverte et l'est dès le chargement d'AmigaOS. Pour ouvrir une bibliothèque, vous devez fournir son nom complet ou simplement son nom (sans l'extension ".library"). Notez que sous ACE Basic, c'est la bibliothèque dos.library qui est toujours ouverte.
Exemple : ouverture d'intuition.library :
LIBRARY intuition LIBRARY "intuition.library" |
Utilisation des fonctions d'une bibliothèque
Avant de pouvoir utiliser des fonctions, vous devez les déclarer à l'aide de l'instruction DECLARE FUNCTION. Son format est le suivant :
DECLARE FUNCTION <name>[%&!#$] [(parameter-list)] LIBRARY [<libname>] |
...où "name" est le nom de la fonction, les symboles déterminent le type de retour, "parameter-list" est une liste de valeurs optionnelles à transmettre à la fonction et "libname" est un nom de bibliothèque optionnel dans lequel le BASIC recherchera la fonction. Le pourcentage (%) représente les entiers courts, l'esperluette (&) les entiers longs, le point d'exclamation (!) les nombres à simple précision, le dièse (#) les nombres à double précision et le dollar ($) les chaînes de caractères. Exemple :
DECLARE FUNCTION SetSoftStyle LIBRARY |
Pour appeler une fonction de bibliothèque, vous pouvez utiliser la commande CALL avec le nom de la fonction et les paramètres nécessaires, ou l'intégrer à une expression. Par exemple :
CALL SetSoftStyle(param1, param2...) |
Fermeture d'une bibliothèque
Pour fermer une bibliothèque, utilisez l'instruction LIBRARY CLOSE qui ferme toutes les bibliothèques ouvertes.
15. Fonctions intégrées [retour au plan]
Le langage BASIC possède un large éventail de fonctions intégrées permettant de manipuler les nombres et les chaînes de caractères. Vous pouvez utiliser ces fonctions presque partout dans votre programme où une expression est requise comme entrée pour d'autres instructions et fonctions.
Fonctions numériques
- ABS(n) : valeur absolue. Renvoie la valeur absolue et positive du nombre. Par exemple : ABS(70)=70, ABS(-33)=33.
- ASC(x$) : renvoie le code ASCII du premier caractère de la chaîne.
- ATN(n) : arctangente. Renvoie l'arctangente du nombre n, exprimé en radians. Le résultat est compris entre -Pi/2 et Pi/2 radians.
- CBDL(n) : convertit un nombre en une valeur double précision.
- CINT(n) : convertit un nombre en un entier en arrondissant la partie décimale (n=-32768 à 32767).
- CLNG(n) : convertit un nombre en un entier long.
- COS(n) : cosinus. Renvoie le cosinus de la valeur n, exprimée en radians.
- CSNG(n) : convertit un nombre en un nombre simple précision.
- CSRLIN : renvoie la ligne du stylo.
- CVI(2-byte-string) : convertit une chaîne numérique en entier court.
- CVL(4-byte-string) : convertit une chaîne numérique en entier long.
- CVS(4-byte-string) : convertit une chaîne numérique en nombre simple précision.
- CVD(8-byte-string) : convertit une chaîne numérique en nombre double précision.
- EOF(filenumber) : vérifie la fin du fichier. Renvoie vrai (-1) si la fin du fichier est atteinte.
- ERR : renvoie le dernier numéro d'erreur. Voir l'instruction ON ERROR.
- ERL : renvoie le numéro de ligne de l'instruction où l'erreur s'est produite. Voir l'instruction ON ERROR.
- EXP(n) : logarithme népérien. Renvoie e^n, où "e" vaut 2,7182818284590.
- FIX(n) : renvoie la partie entière tronquée du nombre n. Identique à INT, mais sans arrondi.
- FRE(n) : renvoie la quantité de mémoire libre. Si n=-1, renvoie la mémoire libre totale ; si n=-2, renvoie l'espace libre sur la pile ; sinon, renvoie la mémoire libre dans le segment de données.
- INT(n) : renvoie le plus grand entier inférieur ou égal à n.
- LBOUND(array-name[,dim]) : renvoie l'indice le plus bas du tableau ou d'une dimension spécifique du tableau (généralement 0 ou 1).
- UBOUND(array-name[,dim]) : renvoie l'indice le plus élevé du tableau ou d'une dimension spécifique du tableau.
- LOC(filenumber) : renvoie le numéro du dernier enregistrement lu ou écrit dans le fichier.
- LOF(filenumber) : renvoie la longueur du fichier en octets.
- LOG(n) : renvoie le logarithme népérien (e) du nombre n.
- LPOS(n) : renvoie la position actuelle de la tête d'impression dans le tampon de l'imprimante. "n" est un argument fictif.
- MENU(n) : renvoie le numéro du dernier élément de menu sélectionné.
- MOUSE(n) : renvoie l'état du bouton de montage si n=0. Si n=2 à 5, la fonction renvoie la position actuelle, la position de départ et la position finale du curseur de la souris.
- OBJECT.VX(obj-id) : renvoie la vitesse de l'objet selon l'axe x (horizontal).
- OBJECT.VY(obj-id) : renvoie la vitesse de l'objet selon l'axe y (vertical).
- OBJECT.X(obj-id) : renvoie la position x de l'objet.
- OBJECT.Y(obj-id) : renvoie la position y d'un objet.
- PEEK(adress) : renvoie un entier d'un octet depuis une adresse mémoire.
- PEEKL(adress) : renvoie un entier long depuis une adresse mémoire.
- PEEKW(adress) : renvoie un entier court depuis une adresse mémoire.
- POINT(x,y) : renvoie l'identifiant de couleur d'un point dans la fenêtre courante.
- POS(x) : renvoie le numéro de colonne du stylo dans la fenêtre courante.
- RND([x]) : renvoie un nombre aléatoire entre 0 et 1 (si x<0, la séquence recommence ; x=0, le dernier nombre est répété ; x>0, le nombre suivant est généré (par défaut)).
- SGN(n) : renvoie la valeur de n par rapport à zéro. Si n<0, la fonction renvoie -1 ; si n=0, elle renvoie 0 ; si n>0, elle renvoie 1.
- SIN(n) : renvoie le sinus de n, où "n" est exprimé en radians.
- SQR(n) : renvoie la racine carrée de n.
- STICK(n) : renvoie la direction de la manette. Si n=0, renvoie la direction X de la manette A ; si n=1, renvoie la direction Y de la manette B ; si n=2, renvoie la direction X de la manette B ; si n=3, renvoie la direction Y de la manette B.
- STRIG(n) : renvoie l'état du bouton de la manette. Si n=0, renvoie 1 si le bouton de la manette A a été pressé récemment ; si n=1, renvoie 1 si le bouton de la manette A est actuellement pressé ; si n=2, renvoie -1 si le bouton de la manette B a été pressé récemment ; si n=3, renvoie -1 si le bouton de la manette B est actuellement pressé.
- TAN(n) : renvoie la tangente de n, où n est exprimé en radians.
- VAL(x$) : renvoie la valeur numérique de la chaîne.
- VARPTR(var-name) : renvoie l'adresse du premier octet de la variable.
- WINDOW(n) : renvoie des informations sur une fenêtre, par exemple son identifiant, sa largeur, sa hauteur, sa position et ses couleurs.
- CHR$(n) : renvoie le caractère correspondant à la valeur ASCII n.
- DATE$ : renvoie la date actuelle (format jj-mm-aaaa).
- HEX$(n) : renvoie la valeur hexadécimale de la valeur décimale n.
- INKEY$ : renvoie une chaîne d'un caractère correspondant au caractère lu au clavier.
- INPUT$(x [,]#]filenumber) : renvoie une chaîne de x caractères extraite du fichier numéroté "filenumber".
- INSTR([i,] X$, Y$) : renvoie la position de la chaîne Y$ dans la chaîne X$, à partir de la position i.
- LEFT$(X$, I) : renvoie les "I" caractères situés à gauche de la chaîne X$.
- LEN(X$) : renvoie le nombre de caractères dans la chaîne X$.
- MID$(X$, start, len) : renvoie les caractères du milieu de la chaîne X$, à partir de la position "start", sur une longueur de "len" caractères.
- MKI$(n) : convertit un entier court en une chaîne de deux octets.
- MKL$(n) : convertit un entier long en une chaîne de quatre octets.
- MKS$(n) : convertit un nombre simple précision en une chaîne de quatre octets.
- MKD$(n) : convertit un nombre double précision en une chaîne de huit octets.
- OCT$(n) : renvoie la valeur octale sous forme de chaîne, pour la valeur décimale n.
- RIGHT$(X$, I) : renvoie les "I" premiers caractères de la chaîne X$.
- SADD(X$) : renvoie l'adresse du premier octet de la chaîne X$.
- SPACE$(n) : renvoie une chaîne de "n" espaces. Similaire à SPC().
- STR$(n) : convertit le nombre "n" en une chaîne équivalente.
- STRING$(I, [J | X$]) : renvoie une chaîne de longueur "I" contenant le code ASCII "J" ou le caractère de X$.
- TIME$ : renvoie l'heure actuelle (format : hh:mm:ss).
- TRANSLATE$(X$) : traduit les mots anglais en phonèmes pour l'instruction SAY.
- UCASE$(X$) : convertit la chaîne en majuscules.
- PTAB(n) : déplace la position d'affichage au pixel "n" (0-32767).
- SPC(n) : Affiche "n" espaces.
- TAB(n) : tabule jusqu'à la "n"ième colonne.
- ALLOC(byes, type) : alloue des octets de mémoire membre dans Chip(0), Fast(1) ou Public(2). Ajouter 3 efface également la mémoire. Renvoie l'adresse de début.
- ARG$(n) : renvoie l'argument de la ligne de commande correspondant au "n"ième élément de la liste d'arguments.
- ARGCOUNT : renvoie le nombre d'arguments dans la ligne de commande.
- BIN$(n) : renvoie la chaîne binaire équivalente au nombre décimal "n".
- CSTR(addr) : convertit une adresse entière longue en chaîne de caractères.
- DAY : renvoie le jour de la semaine sous forme numérique (0=dimanche, 6=samedi).
- FILEBOX$(title, dir) : lance une requête de fichier et renvoie le chemin du fichier.
- HANDLE(filenumber) : renvoie un pointeur vers un descripteur de fichier DOS utilisable avec les fonctions DOS.
- HEADING : renvoie l'orientation actuelle de la tortue en degrés (0-359).
- IFF(channel, n) : renvoie des informations sur le fichier graphique IFF avec le canal spécifié (1-255). Info req n=0-4.
- INPUTBOX(prompt, title, default, xpos, ypos) : affiche une requête et renvoie une valeur entière longue.
- INPUTBOX$(prompt, title, default, xpos, ypos) : affiche une requête et renvoie une chaîne de caractères.
- MSGBOX(message, text1, text2) : affiche une requête système avec un ou deux boutons utilisant text1 et text2.
- POTX(n) : renvoie la valeur du potentiomètre de la manette ou du périphérique connecté au port manette. n=0 ou 1.
- POTY(n) : renvoie la valeur du potentiomètre de la manette ou du périphérique connecté au port manette. n=0 ou 1.
- SAY(n) : renvoie vrai ou faux si la synthèse vocale est active (n=0), renvoie la largeur de la bouche (n=1), renvoie la hauteur du support (n=2).
- SCREEN(n) : renvoie des informations sur l'écran actuel (n = 0 à 6).
- SERIAL(channel, n) : renvoie des informations provenant d'un port série (channel=1 à 255, n=0 à 12).
- SHL(n, m) : décale la valeur "n" de "m" positions binaires vers la gauche.
- SHR(n, m) : décale la valeur "n" de "m" positions binaires vers la droite.
- SIZEOF(ident) : renvoie la taille d'une variable, d'un tableau ou d'une structure en octets.
- TIMER : renvoie le nombre de secondes écoulées depuis minuit.
- XCOR : renvoie les coordonnées x de la tortue actuelle.
- YCOR : renvoie les coordonnées y de la tortue actuelle.
|
