Vous êtes intéressés par la programmation de votre TI-83 ? Vous voulez vous aussi créer des programmes divers, des logiciels ou des jeux sur votre TI-83, TI-82 ou même sur votre TI-89 ? (le langage utilisé est généralement le même : le TI-basic) Cette page est faite pour vous ! A travers plusieurs exemples détaillées et des photos d'écran de ma TI (images crées à l'aide du TI-graph link), vous pourrez facilement et rapidement apprendre à programmer votre calculatrice en TI-basic ! Nous analyserons chaque instruction, du If, au GetKey, en passant par le Input, le Disp ou les instructions graphiques !
Ce sont les commandes du premier menu, celui de gauche. Elles permettent de
contrôler le programme, en disant ce qu'il doit faire selon certaines
conditions. Ces commandes sont au coeur de la programmation mais sont très
souvent invisibles, car elles ne demandent ni ne renvoient rien à l'écran.
Pratiquement toutes les commandes de type "CTL" fonctionnent donc
avec des variables, qui n'ont encore une fois pas besoin d'être affichées.
Pour des programmes plus visuels, et donc plus compréhensibles, nous
allons utiliser des instructions telles que "Disp" qui permettront
de noter les modifications apportées par ces instructions de contrôle.
Ces affichages ne sont pas nécessaires. Par exemple dans un jeu, quand
on appuyera sur la flèche "gauche" pour faire bouger le curseur,
une variable aura changé (on aura utilisé une instruction de boucle
et une de condition (avec un opérateur booléen)) pour enregistrer
la nouvelle position du curseur, mais on n'affichera ni le nom de la variable,
ni sa valeur (sauf peut-être dans une bêta version pour trouver
un bug). On ne verra que le curseur qui bouge (et encore, on peut ne pas le
faire bouger, et laisser le changement de valeur, mais alors, quel est l'intérêt
? :-p), et pas la variable.
Crée un test de condition. Si la condition placée après l'instruction If est vraie, la ligne de code suivante est exécutée. Sinon, elle est omise et le programme continue avec la ligne de code suivante.
ex1 :
![]() :If A>4 Si A est strictement supérieur à 4, :Disp "GRAND" Alors le programme écrira "GRAND". :Disp "FIN" Et dans tous les cas, il écrira "FIN" :Stop et le programme se terminera |
ex2 :
![]() :If B>5 On décrète alors que si cette valeur est strictement supérieure à 5 (et elle l'est), :Disp "B EST GRAND" Le programme écrira "GRAND" en haut à gauche de la fenêtre. :Disp "SALUT" Ensuite, et dans tous les cas, il écrira "SALUT" :Stop et le programme se finira par l'instruction "Stop" optionnelle. |
Annexe : les opérateurs booléens : Les instructions sont éxécutées par le programme si l'expression
conditionnelle est "vraie". Pour différencier le vrai du faux,
le langage (comme tous les langages informatiques) transforme l'expression en
1, ou en 0, suivant la condition. Des opérateurs booléens sont
donc nécessaires pour cette transformation.
Les autres opérateurs se trouvent dans le menu d'à côté intitulé "Logique". Ils sont très utiles, mais certains s'utilisent bien plus que d'autres :
Exemple d'utilisation d'opérateurs booléens :
If 1
ce qui équivaut à "true". Autrement dit, à l'instruction, "Si
3 fois A sur 5 est égal à 5 fois B sur 3 et que C² = 25 ou
bien que C² sur A+B est égal à C ou bien, -si tout ça
est faux-, si A est égal à 8", on répond "vrai"
et les instructions correspondant à la condition sont éxécutées.
|
Crée encore un test de condition, mais permet cette fois-ci d'insérer plusieurs lignes de codes exécutées après la condition. C'est la méthode la plus utilisée pour insérer de longues instructions.
Exemple :
:8![]() :Prompt A On demande ensuite une valeur au joueur, qui sera enregistrée sous A. :Then Alors, tout ce qui suit sera exécuté : :Disp "B EST PROCHE..." On dira tout d'abord que B est proche, :Disp "CHERCHE ENCORE" Puis on demandera au joueur de chercher encore... :Goto 0 Ensuite, le programme ira à l'étiquette 0 (située plus bas) :End Et la condition s'arrête ici (le programme pourra exécuter ce qui suit) :Then Alors :Disp "BRAVO !" On le félicitera :Disp "TU ES TRES FORT" et on le flattera. :Goto 0 Le programme ira ensuite à l'étiquette 0 située plus bas :End Et la condition s'arrête encore ici. :Disp "A UNE AUTRE FOIS !" et "A UNE AUTRE FOIS" :Lbl 0 Ici, on retrouve l'étiquette 0 vers laquelle on est dirigée après chaque cas, :Stop Et le programme s'arrête. |
Cette instruction permet d'exécuter une liste de commandes lorsqu'une condition est respectée, et lorsqu'elle ne l'est pas, ce qui peut aussi être très utile dans certains cas... Pour commencer, voici une démonstration de ce que ferait le programme si on utilisait If...Then...End, afin de montrer l'utilité de If...Then...Else...End :
:5![]() :Disp "Calcul des" Ensuite, on écrit "calcul des valeurs :Disp "valeurs B-C..." de B et C" :If C=5 On dit que Si C vaut 5 (c'est le cas ici), :Then Alors :C² ![]() ![]() :Output(4,4,B) On écrit à la ligne 4 et la colonne 5, la VALEUR de B :Output(4,6,"-" Puis, on écrit (à la colonne suivante), ce qu'il y a entre les guillemets, donc le tiret. :Output(4,7,C) Enfin, on écrit la valeur de C, juste après ça. :End Et End signale la fin de la condition :Then Alors :C+8 ![]() ![]() :Output(4,10,B) Ensuite, comme avant, on écrit la valeur de B, :Output(4,11,"-" suivie d'un tiret :Output(4,12,C) et de la valeur de C :End Et la condition s'arrête ici (le programme aussi d'ailleurs, mais l'instruction "Stop" est optionnelle.) |
Et là, on voit que les deux "codes", ou "suites de valeurs B-C" sont affichées, alors qu'au début, on aurait voulut faire une condition pour le cas où C=5 (2-10), et une condition pour C différent de 5 (1-5), alors que là, les deux conditions ont été prises en compte, donc les deux codes ont été affichés. Pour remédier à ça, on va utiliser l'instruction Else, pour faire une suite conditionnelle If...Then...Else (Si...alors...sinon) :
ex1 :
Et donc, seul le code 25-10 (ou C²-10 ou B-C) s'affiche. On traduira le principal du code source par "Si C est égal à 5, alors [...], sinon [...] Fin" Et c'est évidemment le "alors" qui est pris en compte. |
ex2 :
Ici, seule les lignes de codes qui suivent Else sont exécutées, car C est différent de 5. C'est donc l'instruction "sinon" (ou Else" qui est prise en compte. |
For fait partie des instructions"loop", c'est-à-dire celle
qui se répètent, ou plutôt qui répètent ce
qui est contenu entre elles et End. Encore une fois, il ne faut surtout pas
oublier l'instruction End, sinon le programme commence à faire n'importe
quoi...
La syntaxe de For est : For(variable, départ, arrivée, [incrément
ou pas]), c'est à dire qu'après la parenthèse ouverte par
l'instruction For, il faut mettre le nom de la variable qui va changer, puis
la valeur de départ de cette variable, et la valeur d'arrivée,
c'est à dire jusqu'où on veut qu'elle varie. Ces 3 arguments sont
indispensables pour le bon fonctionnement de l'instruction. Le dernier, l'incrément,
est optionnel, il a la valeur de 1 par défaut, mais il est parfois nécessaire
de le changer (Si vous mettez un nombre négatif, veillez à mettre
le "moins" des nombres négatifs, et pas celui de la soustraction).
L'incrément détermine tout les combien d'unités il faut
changer la variable. Voici des exemples :
ex1 :
:Disp F On affiche la valeur de F :End Et l'instruction se termine, de même que le programme. |
ex2 :
:Disp F :End |
ex3 :
Evite de tracer chaque ligne, et donne ça (avec mes réglages prédéfinis, voir section draw) :
ex4 :
:ClrDraw Tout d'abord, on efface les dessins préexistants (il faudrait même s'assurer de l'absence de fonctions) :Text(23,35,"CREE PAR :" On met un peu de texte pour faire joli :Text(30,25,"WRTAL YANNICK" :Line(15,0,15,62) On trace une ligne du bas vers le haut, à 15 pixels du bord gauche (abscisse=15) :Line(79,0,79,62) On fait la même chose du côté droit. ![]() :Line(47,0,94,31) Et on continue à tracer de petites droites pour faire joli, et remplir un peu l'écran. :Line(47,62,0,31) :Line(47,62,94,31) :Pause Une fois qu'on a fait nos petits dessins (on peut faire n'importe quel dessin), on met une pause :For(F,0,62) Et on va faire varier, pendant la séquence qui suit, la variable F de 0 à 62 (0=bord bas ; 62=bord haut) :Line(0,F,94,F,0) Là, on efface une ligne d'abscisse 0 à 94 (toute la largeur) et qui va monter grâce à For (le 0 à fin efface la ligne) :End Et voici la fin de l'instruction : l'écran a été joliment effacé ! Ces trois lignes de codes sont souvent utilisées, c'est mieux que ClrDraw ! |
ex5 :
:While 1 Tout ce qui suit jusqu'à End est infiniment répété :For(F,1,8) Pendant les 4 lignes de codes suivantes, on augmentera la valeur de F de 1 à 8. :ClrHome On effacera l'écran :Output(F,3, "HELLO WORLD !") Et on écrira (à une ligne variable de 1 à 8), un petit message bien connu... ![]() :End:End Et 2 End terminent les instructions for :For(F,7,2,-1) En suite, quand F est égal à 8, on ramène progressivement sa valeur à 2 :ClrHome :Output(F,3,"HELLO WORLD !") et tout ce qui suit est la même chose que dans l'instruction For précédente. :For(A,1,50) :End:End :End Quand F est à nouveau égal à 2, on retourne au début du programme. (ceci est le End du While pour revenir au début) |
While est une instruction de boucle, comme For (et comme Repeat). La syntaxe est la même que dans la langue française, sachant que While signifie "Pendant que". Le premier programme qui utilisera while sera très simple ; il augmentera la valeur d'une varible jusqu'à ce qu'elle soit égale à 5 :
ex :
:3![]() :While A (inférieur ou égal à) 5 On dit que "Pendant que la variable A sera inférieure ou égale à 5, :Disp A : A+1 ![]() :End Et c'est ici que s'arrêtera l'instruction while, ou plutôt, que le programme retournera à cette instruction si la condition n'est pas respectée... :Disp "Objectif Atteint",A Quand A sera supérieur à 5, le programme continuera en écrivant un message, suivi de la valeur de A ! On obtiendra alors : |
L'instruction Repeat est exactement le contraire de l'instruction While. Aussi, au lieu d'écrire While 8x+6=4, on écrira simplement Repeat 8x+6 (différent de) 4. Précisons qu'en d'autres langages plus évolués (sur PC, comme le C par exemple), cette instruction équivaut aux instructions "Do...While;" ; c'est-à-dire que la boucle est executée au moins une fois, contrairement à While. Pour commencer, on va faire un programme qui résoud l'équation A/2=B+3 où A et B sont égaux à 0 (c'est faisable de tête, je sais !). On pourrait faire le programme While, mais ça ne vous apprendrait rien si je mettais son code source ici ; je vais donc faire ce petit programme, qui est encore une fois faisable avec l'instruction While :
ex :
:0![]() ![]() :Repeat A/2=B+3 On répète tout ce qui suit (jusqu'à End), jusqu'à ce que la moitié de A soit égale à 3 :A+1 ![]() :Output(4,9,B) Et l'affiche de la valeur de B, 2 colonnes plus loin. :End Et L'instruction End termine l'instruction Repeat (comme toutes les instructions Loop) :Output(6,4,"TERMINE") Une fois que la condition est respectée, on écrit "TERMINE" 2 lignes en dessous, ce qui donne ceci : |
Résumé des instructions Loop :
Les instructions For, While et Repeat sont appelés instructions Loop. Elles sont caractérisées par le fait de répéter une ou plusieurs lignes de codes jusqu'à ce qu'un condition est remplie. Pour mettre en évidence le lien entre les instructions loop (et les branchements par étiquettes), voici 4 programmes sensiblement différents : ils donnent tous la même chose à l'écran, mais leur code source n'est pas le même, en fait c'est la méthode utilisée qui varie. Pour couronner le tout, j'ajoute des tests conditionnels à l'intérieur, et je les mets dans le désordre, c'est-à-dire que les instructions ne seront dans le même ordre que ce qui apparaîtra à l'écran.
FOR
|
WHILE
|
REPEAT
|
LBL
|
||||
|
|
|
|
Et
pour la fin, je vous ai laissé un programme qui montre bien l'utilité
de For puisqu'il affiche en plus la valeur de A :
La seule chose à faire est de rajouter le nom de la variable A après
la pause dans For, ce qui aura pour effet de mettre une pause dans le programme,
mais d'en profiter pour afficher la valeur de A. Voilà ce que l'on obtient
à l'écran :
La pause, comme son nom l'indique permet de laisser le temps au "joueur" de regarder ce qui est écrit à l'écran, ou simplement pour éviter que le programme ne se poursuive trop vite. Suivi du nom d'une variable, Pause affiche la valeur de la variable concernée, en plus d'interrompre momentanément le programme. Pour continuer l'execution du programme après une pause, il faut appuyer sur "ENTER".
Lbl (label = étiquette) permet d'insérer un repère dans
un programme, vers lequel on pourra être redirigé à l'aide
de l'instruction goto. Cette méthode est ressemble un peu aux instructions
Loop mais n'en fait pas partie.
L'avantge des étiquettes est qu'on peut s'y rendre à n'importe
quel moment, pourvu que l'instruction goto est présente dans le programme.
Le nom de l'étiquette doit être un nombre de 0 à 99, (02
et 2 n'étant pas les mêmes étiquettes), une lettre de A
à Thêta, mais pas d'assemblage de lettres et de chiffres, ni plus
de 2 chiffres ou une lettre. On ne peut toutefois pas relier un programme à
un autre par l'instruction goto.
Voici un exemple de programme utilisant le système d'étiquettes
:
ex1 :
:4![]() :8 ![]() :ClrHome Ensuite, on efface l'écran. :Lbl 12 On place alors une première étiquette appelée étiquette 12 :A+5 ![]() :Output(4,5,A) La valeur de A sera affichée à la 4ème ligne et à la 5ème colonne :If A<13:Then Si A est strictement inférieur à 13, alors :Output(8,1,"A est trop petit") On écrira en bas à gauche que A est trop petit :Pause On mettra une pause pour permettre de lire le message :Goto 12:End Et on reviendra au début du programme, à l'étiquette 12. :For(B,8,20) Après ça, on incrémentera la valeur de B, à partir de 8 jusqu'à 20 :If B>15:Goto F Si B est strictement supérieur à 15 (16 dans ce cas-là, car on augmente la valeur 1 par 1, par défaut), on se rendra directement à l'étiquette F :Output(4,11,B) Et dans tous les cas, si le programme lit cette ligne de code (il ne la lit pas quand B est inférieur ou égal à 15), on affichera la valeur de B :End à la 4ème ligne et à la 11ème colonne, et l'instruction For se termine par End. :Pause Quand on arrive, il y a une pause :Disp "Terminé !" On écrit que le programme est fini sur la première ligne :Disp "A=",A et on affichera les valeurs de A :Disp "B=",B puis de B. |
Les menus sont intéressants car ils permettent de faire un choix, comme
le fait de continuer ou de quitter le programme, ou d'autres choses utiles pour
contourner la linéartité d'un programme. Le menu que nous allons
créer pourrait par exemple être intégrer dans un jeu de
rôles. Par exemple, lorsque le personnage veraa une créature, il
pourra choisir entre saluer cette personne, partir ou l'affronter. Pour montrer
l'intérêt de l'instruction "Menu", nous allons utiliser
trois méthodes de programmation, d'abord, un menu avec l'instruction
"Input", un autre avec l'instruction "Menu", et un dernier
qui sera tout à fait personnalisé, c'est-à-dire que nous
allons entièrement le créer.
En ce qui concerne la syntaxe de "Menu", il faut tout d'abord indiquer
le "titre" du menu, puis l'option 1 entre guillemets (qui sera après
le 1:), puis l'étiquette 1, relative à l'option 1, puis l'option
2 (entre guillemets), puis l'étiquette 2 relative à l'option 2
etc. On peut mettre jusqu'à 7 options. Un exmple de la syntaxe de "Menu"
est : Menu("TITRE DU MENU","Option
1",A,"Option 2",2)
sans oublier de placer plus
loin les étiquettes lbl A
et lbl 2
.
Voici déjà le menu du débutant (programmé avec l'instruction Input), nous allons le nommer Menu1 .Il ne sera pas très beau et prendra 154 octets :
MENU1 :
:ClrHome On efface d'abord l'écran :Disp "1. SALUER" Puis on écrit les options disponibles, à savoir : saluer (en 1) :Disp "2. PARTIR" partir (en2) :Disp "3. SE BATTRE" ou se battre (en 3) :Disp "" puis on n'écrit rien pour laisser un ligne :Lbl 0 Et on place l'étiquette 0 :Input "QUE FAIRE ?",A Ensuite, on demande la valeur de A à travers l'invité "QUE FAIRE ?" :ClrHome Une fois que l'on a répondu, et appuyé sur "ENTER", l'écran s'efface à nouveau :If A>3:Goto 0 Si la valeur entrée est supérieure à 3, on revient en arrière pour la redemander :Disp "SALUT !" on écrit Salut et le programme se termine (pas d'autres possibilités correspondant à A=1) :If A=2 Même chose pour une réponse égale à 2 :Disp "JE M'EN VAIS" :If A=3 et à 3 ! :Disp "BATTONS NOUS !" |
Le programme suivant utilise l'instruction "Menu", il est plus simple et plus esthetique. Il prendra normalement 128 octets, soit moins que tous les autres, et son code source est ici :
MENU2 :
:ClrHome On commence le programme par effacer l'écran, comme d'habitude :Menu("QUE FAIRE ?","SALUER",1,"PARTIR",2,"SE BATTRE",3) Ensuite, on fait un menu, avec le titre "Que faire ?", en 1, on mettra la possibilité de saluer, qui renverra à l'étiquette 1, puis la possibilité de partir en 2, qui reverra à l'étiquette 2, et enfin, en 3, la possibilité de se battre, qui renverra à l'étiquette 3. :Lbl 1 Voici l'étiquette 1 :Disp "SALUT !" Où on saluera le personnage rencontré :Stop On est obligé de mettre l'instruction "Stop" ici pour que les autres instructions ne soient pas éxécutées :Disp "JE M'EN VAIS !" On écrit un message, :Stop et là encore, on est obligé de mettre l'instruction Stop, pour que "BATTONS NOUS" ne s'affiche pas :Lbl 3 Ici, l'étiquette 3 relative au 3ème choix :Disp "BATTONS NOUS !" Et la conséquence du troisième choix, qui ne nécessite pas d'instruction "Stop" car elle est la dernière. |
Vous remarquerez la meilleure présentation de ce menu par rapport à
celui d'avant. Non seulement, on est obligé de choisir une des 3 possibilités
(impossible d'en choisir une quatrième), mais en plus de pouvoir choisir
le numéro de la possibilité, on peut aussi "naviguer"
dans le menu avec les flèches, sans aucune donnée graphique, ce
qui n'est possible que par une instruction telle que "Menu" qui met
le texte en forme automatiquement. Ce programme ne prend normalement que 128
octets, comparés aux 154 du MENU1, ou encore aux 409 du menu3...
Le menu3 est en effet un peu spécial : c'est un menu totalement personnalisé,
et unique, puisque vous devez l'inventer. En fait, il est fait grâce aux
opérations draws, qui seront expliquées dans la section correspondante.
Ne vous inquiétez pas si vous ne comprenez pas ce menu, ce genre de menu
est en effet fait pour une élite, pour les programmes les plus complexes,
et les mieux faits. Vous trouverez un exemple de menu personnalisé dans
le groupe BATNAV. Mais venons-en maintenant à la syntaxe du programme
Menu3 (/!\ Je précise toutefois que ce menu ne fonctionne qu'avec mes
réglages prédéfinis, à savoir : 94 pixels en largeur,
62 en hauteur, et les axes désactivés) :
MENU3 :
:ClrHome D'abord, on efface l'écran :ClrDraw et les dessins (il faudrait aussi mettre les reglages ici théoriquement, et enlever les graphiques etc.) :Text(5,28,"QUE FAIRE ?" Puis, on écrit le titre :Line(26,50,66,50) qui sera souligné :Text(20,30,"SALUER" :Text(30,30,"PARTIR" Puis, on écrit les options disponibles :Text(40,30,"SE BATTRE" :1 ![]() ![]() :Lbl A On place l'étiquette A ici :Line(19,A,25,A) :Line(24,A-1,24,A+1) Et on dessine la flèche en fonction de A (au début du programme, A=39, A-1=38 etc.) :Line(23,A-2,23,A+2) :Repeat K=25 or K=34 or K=105 Ensuite, on repète ce qui suit jusqu'à ce K soit égal à 25 (haut), 34 (bas) ou 105 (entrée) :GetKey ![]() :End Et l'instruction Repeat s'arrête ici< :If K=105:Goto F Si on a ppuyé sur "ENTER", le programme se rend en bas, à l'étiquette F :Line(19,A,25,A,0) :Line(24,A-1,24,A+1,0) Dans tous les autres cas (K=25 ou K=34), la flèche est effacée :Line(23,A-2,23,A+2,0) :If K=25:Then Si on appuyé sur "haut", alors :If E=1:Then D'abord, si la flèche était à la première ligne, :3 ![]() ![]() :Goto A:End Et on se rendra à l'étiquette A, en haut, pour placer la flèche en fonction de A :E-1 ![]() ![]() :Goto A:End Et on se rendra en haut, à l'étiquette A, pour afficher la flèche en fonction de A :If K=34:Then Même chose si on appuie sur "Bas" :If E=3:Then: :1 ![]() ![]() :Goto A:End :E+1 ![]() ![]() :Goto A:End puis, retour à l'étiquette A :Lbl F Le programme se rend à cette étiquette quand K=105 (l'utilisateur a appuyé sur "ENTER") :ClrDraw Ici, tous les dessins (donc le menu) sont effacés :If E=1 Si E (emplacement de la flèche) était égal à 1 (flèche sur choix 1), :If E=2 Et les valeurs 2 et 3 correspondent aux lignes 2 et 3, à savoir : :Disp "JE M'EN VAIS !" "PARTIR" pour E=2 (comme dans les autres programmes) :If E=3 :Disp "BATTONS NOUS !" et "SE BATTRE" pour E=3 (toujours comme dans les autres programmes) |
Voilà ! Le programme Menu3 est enfin terminé, mais vous disposez maintenant d'un menu pas comme les autres !
Quand les programmes sont trop gros, ou quand on veut travailler sur des petits
codes sources, on peut couper un programme en plusieurs. Pour passer d'un programme
à un autre, on utilise l'instruction "prgm". Son utilisation
est simple : à l'endroit de la source où l'on veut éxecuter
un autre programme, on écrit la commande "prgm" suivie immédiatement
du nom du programme à appeler. Ex : If A=1 : prgmSALUT. En gros, cette
manipulation revient à faire un copier-coller, sauf que les lignes du
programme appelées ne sont pas restranscries : c'est donc un RACCOURCI,
ce qui implique qu'il faut évidemment laisser le programme à appeler
sur la calculatrice ; le suppimer provoquerait une erreur de syntaxe.
L'instruction return, quant à elle, sert à revenir dans le programme
qui a appelé celui qui la contient. (Ex : Le programme A fait "prgmB",
le programme B fait "return" : on reviendra donc dans le programme
A, après l'instruction "prgmB".) L'avantage de cette commande
est qu'elle revient dans le programme d'origine, juste après l'instruction
"prgmNOM_DU_PRGM", et non pas au début du code source, comme
si l'on avait utilisé l'instruction "prgm". Mais venons-en
à l'exemple :
ex : BASE
:Disp "Ce programme va" :Disp "appeler un autre" Ensuite, on dit que le programme "BASE" va en appler un autre... :Disp "programme." :For(A,1,750) Ici, on fait une pause : on fait varier F de 1 à 750 pour rien, enfin, juste pour qu'il y ait du temps qui se passe, :End ce qui évite une pause. L'instruction se termine bien sûr par End :ClrHome On efface de nouveau l'écran :Disp "Appuie sur ENTER" :Disp "pour voir le" Et on dit qu'il faut appuyer sur "Entrée" pour voir le générique (c'est-à-dire pour lancer le programme "DISCIPLE") :Output(4,4,"GENERIQUE !") :Pause Ici, on met la pause (qui nécessite l'appui sur ENTER pour continuer) :prgmDISCIPLE C'est ici que tout ce joue : on lance le programme "DISCIPLE" (en vert ci dessous, mais qui ne doit évidemment pas se trouver dans le code final de "BASE" !!!) : :ClrHome Une fois qu'on est revenu dans le programme disciple, on efface à nouveau l'écran :Disp "Voilà !" :Disp "generique" Et on écrit un petit texte de salutation (tiens, d'ailleurs je n'ai même pas mis l'adresse de mon site ! :-P) :Disp "A bientôt sur" :Disp "mon site !" :Stop Et on termine avec l'instruction Stop, optionnelle ici. |
L'instruction Stop est généralement totalement optionnelle. On peut la mettre à la fin d'un programme simple mais ça ne sert généralement à rien. Il peut toutefois arriver qu'on aie besoin de l'utiliser lorsqu'on change de programme avec "prgm/return" (il m'est arrivé un gros bug dans la bataille navale lorsqu'on sauvegardais la partie : l'image du menu était enregistrée au lieu d'enregistrer celle du "plateau de jeu", ce qui fait que l'écran du joueur qui avait sauvegardé était complètement inutilisable car on voyait "jouer/charger/sauvegarder" au lieu de voir ses bateaux...) mais l'instruction Stop peut aussi s'avérer utile lorsque l'on quitte le programme au milieu du code source (légalement, donc sans appuyer sur "on"), car si on ne met met pas cette instruction, le programme continue. C'est cet exemple que j'ai choisis d'illustrer pour ce didacticiel :
Ex1 :
:ClrHome Ici, on efface l'écran :Disp "GENERATEUR DE" On écrit que le programme est :Disp "NOTES" un générateur de notes :Pause Puis, on met une pause pour avoir le temps de lire :ClrHome On ré-efface l'écran :randInt(1,20) ![]() :If A>15 Si la note est bonne, :Goto 15 On va à l'étiquette 15 :If A(<= (inférieur ou égal))5 Si elle est vraiment nulle :Goto 5 On va à l'étiquette 5 :If A(<=)15 et A>10 Si elle est moyenne, :Goto 10 On va à l'étiquette 10 :Disp "VOUS AVEZ ENTRE" Et si elle ne correspond à aucune des conditions, c'est qu'elle est comprise :Disp "5 et 10 !",A entre 5 et 10. On l'écrit, accompagnée de sa valeur exacte :Pause Puis on met une pause pour avoir le temps de lire... :Stop Et là, le programme s'arrête pour ne pas executer les autres instructions :Lbl 15 Quand on arrive ici, (A>15) :Disp "BRAVO !",A on félicite le joueur et on écrit la valeur exacte de sa note. :Stop Et le programme prend fin. :Lbl 5 Quand la note est inférieure à 5, on informe le joueur :Disp "HORRIBLE !",A de la médiocrité de sa note, et on l'affiche. :Stop Le programme s'arrête alors. :Lbl 10 Quand la note est située entre 5 et 10, on met encore un petit message :Disp "PASSABLE...",A et on écrit la valeur exacte de la note. Ici, on n'a pas besoin de spécifier que le programme se termine par l'instruction "Stop" car c'est la dernière ligne de code. |
EX2 :
:ClrHome :Disp "GENERATEUR DE" Ici, on s'en doute, tout le code source :Disp "NOTES" est le même... :Pause :ClrHome :randInt(1,20) ![]() :If A>15 :Goto 15 :If A(<= (inférieur ou égal))5 :Goto 5 :If A(<=)15 et A>10 Les conditions... :Goto 10 :Disp "5 et 10 !",A :Pause Et là, on remarque que l'instruction "Stop" est absente :Lbl 15 On arrive donc ici quoi qu'on fasse ! :Disp "BRAVO !",A Et on félicite le joueur même 'il a un 0 !!! :Lbl 5 Pareil ici... :Disp "HORRIBLE !",A où on peut s'horripiler devant un 20 !!! :Disp "PASSABLE...",A Où n'importe quelle note est considérée comme passable !!! Ici, on n'a pas besoin de spécifier que le programme se termine par l'instruction "Stop" car c'est la dernière ligne de code. On remarque ici que ce programme écrit tout quand la note est 9 !!! Ce qui n'était bien sûr pas souhaité ! |
GraphStyle est une instruction très peu utilisée, pour la bonne
raison que c'est une instruction plutôt destinée aux programmes
de graphiques, de mathématiques. La syntaxe de GraphStyle est la suivante
: Graphstyle(#Fonction,#Style)
, ou #Fonction est le numéro
de la fonction Y= (comme Y1, Y2 etc.), et ou #Style est
le type de tracé utilisé, ce pour quoi la fonction est faite.
Les types de tracés sont les suivants :
Voici un exemple de programme fait avec GraphStyle, qui montre la fonction fx=x et gx=x² (et la zone inférieure à X mais supérieure à X²), puis l'endroit ou x est égal à x² (en draw) :
Ex. :
:0![]() :ClrDraw On efface les dessins :-1 ![]() :-1 ![]() :2 ![]() :2 ![]() :AxesOn Et on active les axes :"X" ![]() :"X2" ![]() :GraphStyle(1,3) On dit ici qu'il faut ombrager les valeurs supérieures de (X,Y) lorsque Yest égal à X (première fonction) :GraphStyle(2,2) Là, on détermine le type de tracé de la seconde fonction (Y=X²) : en gros trait :Lbl 0 On place l'étiquette 0 ![]() :DispGraph On montre (on affiche) les graphiques :Pause On fait une pause pour les admirer :If A:Stop Si A est différent de 0 (ce n'est pas le cas la première fois), le programme s'arrête :0.5 ![]() :0.5 ![]() :1.5 ![]() :1.5 ![]() :1 ![]() :Line(1.02,0.98,1.1,0.9 :Line(1.02,0.98,1.05,0.98 On trace une flèche avec les coordonnées des points :Line(1.02,0.98,1.02,0.95 :Text(40,60,"{1,1}" Et on écrit en dessous les coordonnées de l'intersection ![]() :Text(47,57,"X²=X" Ainsi que la particularité du point :Goto 0 Ensuite on revient plus haut, à l'étiquette 0. |