Les commandes de programmation sur les calculatrices TI :

 

 

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 !

 

 

 

I. Les commandes de type CTL (Contrôle) :

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.

 

 

If

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 :
:3A Ici, on attribue la valeur de 3 à la variable A.
: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 :
:8B Là, on attribue la valeur de 8 à la variable B.
: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 opérateurs booléen sont tous ceux qui ne peuvent renvoyer que deux informations : 0 ou autre (généralement 1). Le 0 sera interpreté comme false (faux), et le 1 comme true (vrai). Sur TI 83, (et bien sûr, tous les modèles rapprochés), ces opérateurs booléens se trouvent dans le menu "test", 2nde fonction de la touche "maths". Ils sont (dans l'ordre) :

  • = qui permet de vérifier l'égalité de deux expressions. Si les deux expressions situées à côté de = sont égales, l'opérateur renvoie 1. Sinon, il renvoie 0.
  • (différent de) qui est l'opposé de =. Les deux expressions situées à côté de (différent de) ne doivent pas être égales pour que l'opérateur renvoie 1.
  • > renvoie 1 si l'expression située avant elle est strictement supérieure à celle située à sa droite !
  • (supérieur ou égal à) est la même que celle d'avant mais les deux expressions peuvent être égales !
  • < est l'inverse de >
  • (inférieur ou égal à) est l'inverse de (supérieur ou égal à) :-p

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 :

  • and (et) renvoie 1 si les deux expressions d'à côté sont égales à 1. Si une seule d'entre elles n'est pas juste, toute l'expression concernée sera égale à 0. Vous comprendrez mieux dans l'exemple.
  • or (ou). Ou renvoie 1 si au moins une des deux expressions est égale à 1. Encore une fois, l'exemple illustrera mieux l'utilisation de ces instructions.
  • xor (ouExcl) Le Ou Exclusif ne renvoie 1 que si l'une des deux expressions, et seulement une est égale à 1. Si les deux le sont, ou si aucune ne l'est, l'instruction enière sera égale à 0. Pas très utile comme instruction, on peut certainement s'en passer.
  • not( (non(). Cette instruction équivaut au != dans des langages comme le C ou le Java. En gros, c'est le contraire de =, dans le sens ou not(0) renvoie 1, et pour x différent de 0, not(x) renvoie 0. Cette instruction aussi peut se compenser par d'autres codes.

Exemple d'utilisation d'opérateurs booléens :

:2A:3B:5C A vaut 2, B vaut 3 et C vaut 5.
:If 3(A/5) = 5(B/3) and C² = 25 or C²/(A+B) = C xor A = 8 Equivaut à :
:If 3(2/5) = 5(3/3) and 5² = 25 or 5²/(2+3) = 5 xor 2 = 8 (D'abord, on remplace les variables par leur vraie valeur.) Ca équivaut à :
:If 1.2 = 5 and 25 = 25 or 5 = 5 xor 2 = 8 (Et on calcule la valeur réelle des expressions). Ce qui équivaut encore à :

:If ((0 and 1) or 1) xor 0 (Ensuite, on calcule la valeur des expressions utilisant les opérateurs de test). On peut encore simplifier :
:If (0 or 1) xor 0 Puis, on calcule la valeur des expressions utilisant les opérateurs logiques "mineurs" comme AND
:If 1 xor 0 Ensuite, on recalcule la valeur des expressions utilisant OR (ou)
:If 1 Et enfin, on calcule ce qui utilise l'opérateur logique qui est certainement le plus "puissant" : OU EXCLUSIF (xor)
On arrive donc à : 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.

 

 

 

If...Then...End

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 :

:8B Tout d'abord, on définit la valeur B à chercher qui est de 8.
:Prompt A On demande ensuite une valeur au joueur, qui sera enregistrée sous A.

:If A-1=B ou A+1=B Cas n°1 : Si l'écart entre A et B est de 1 (on aurait aussi pu écrire If Abs(B-A)=1),
: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)

:If A=B Maintenant, si la valeur donnée par le joueur est la même que celle générée par le programme (8),
: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 "DOMMAGE !" Si aucune des deux conditions énoncées plus haut n'est respectée, le programme écrira "DOMMAGE"
: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.

 

 

If...Then...Else...End

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 :

 

:5C Tout d'abord, on donne la valeur 5 à la variable C.
: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²B:10C B obtiendra la valeur de C au carré, et C obtiendra la valeur de 10 (ne pas inverser l'ordre, sinon le résultat change)
: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

:If C(différent de)5 Maintenant, si C est différent de 5 (c'est le contraire d'avant), et C'EST LE CAS (C=10)
:Then Alors
:C+8B:5C On rajoute 8 à la valeur de C pour la transformer en B (B=18), et la valeur de C revient à 5
: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 :
:5C Ici, on laisse la valeur de 5 à la variable C.
:Disp "Calcul des"
:Disp "valeurs B-C..."

:If C=5 Si C=5 (et c'est le cas)

:Then Alors,
:C²B:10C
:Output(4,4,B) Le programme exécute toutes les commandes
:Output(4,6,"-"
:Output(4,7,C)

:Else Jusqu'ici (Else signifie If condition contraire...Then et End)
:C+8B:5C
:Output(4,10,B)
:Output(4,11,"-"
:Output(4,12,C)
:End

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 :
:10C Là, on modifie la valeur de C en 10.
:Disp "Calcul des"
:Disp "valeurs B-C..."

:If C=5 Si C=5 (ce n'est pas le cas ici)

:Then Alors
:C²B:10C
:Output(4,4,B) Le programme saute toutes ces instructions
:Output(4,6,"-"
:Output(4,7,C)

:Else Jusqu'ici : "Si C n'est pas égal à 5 (ou Sinon)", alors
:C+8B:5C
:Output(4,10,B)
:Output(4,11,"-" Toutes ces commandes sont exécutées
:Output(4,12,C)
:End Jusqu'à l'instruction de fin de condition "End"

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

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 :
:For(F,0,4) On fait varier la variable F de 0 à 4, par tranche de 1 unité (par défaut)
:Disp F On affiche la valeur de F
:End Et l'instruction se termine, de même que le programme.

ex2 :
For(F,80,30,-15) Là, on fait varier F de 80 à 30, par tranche 15, dans le sens négatif.
: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,0,31)
: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...
:For(A,1,50) Pour ralentir le tout, on fera varier la variable A de 1 à 50 pour que le programme soit plus lent.
: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 :

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 :
:3A On attribue d'abord la valeur de 3 à la variable A (vous devriez commencer à comprendre...), mais on peut mettre n'importe quoi inférieur à 5

:While A (inférieur ou égal à) 5 On dit que "Pendant que la variable A sera inférieure ou égale à 5,
:Disp A : A+1A On écrira sa valeur (on l'affichera ), et on l'augmentera de 1 unité
: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 :

 

 

Repeat :

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 :
:0A:0B Ici, A et B sont tous les deux égaux à 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+1A:Pause Ce qui est répété, c'est l'augmentation de la valeur de A de une unité, suivie d'une pause
Output(4,7,A) Ainsi que l'affichege de la valeur de A sur la 4ème ligne à la 7ème colonne
: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
:0A
:For(A,1,4)
:Pause

:If A=3
Disp "Ces codes sont"

:If A=1
:Disp "Code 1 = 1234"

:If A=4
:Disp "Inutiles !"

:If A=2
:Disp "Pass 1 = ARF"

:End

:Disp "Méthode : FOR"

:0A
:While A<5
:A+1A
:Pause

:If A=3
:Disp "Ces codes sont"

:If A=1
:Disp "Code 1 = 1234"

:If A=4
:Disp "Inutiles !"

:If A=2
:Disp "Pass 1 = ARF"

:End

:Disp "Méthode : WHILE"

:0A
:Repeat A>4
:A+1A
:Pause

:If A=3
:Disp "Ces codes sont"

:If A=1
:Disp "Code 1 = 1234"

:If A=4
:Disp "Inutiles !"

:If A=2
:Disp "Pass 1 = ARF"

:End

:Disp "Méthode : REPEAT"

:0A
:Lbl 0
:Pause
:A+1A

:If A=3:Then
:Disp "Ces codes sont"
:Goto 0:End

:If A=1:Then
:Disp "Code 1 = 1234"
:Goto 0:End

:If A=4:Then
:Disp "Inutiles !"
:Goto 0:End

:If A=2:Then
:Disp "Pass 1 = ARF"
:Goto 0:End

:End

:Disp "Méthode : 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 :

 

 

Pause :

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, Goto :

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 :
:4A On attribue d'abord les valeurs de A et de B, à savoir 4 pour A
:8B et 8 pour B
:ClrHome Ensuite, on efface l'écran.

:Lbl 12 On place alors une première étiquette appelée étiquette 12


:A+5A Et on augmente la valeur de A de 5 unités
: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.

:Lbl F Voici maintenant l'étiquette F
: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.

 

 

Menu :

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

:If A=1 Si on a entré la valeur de 1,
: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

:Lbl 2 Ensuite, on trouve l'étiquette 2 correpondant à la possibilité de "PARTIR"
: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"

:1E:39A On donne la valeur de 1 à E (qui correspond au choix) et de 39 à A (qui correpond à l'ordonnée de la flèche)

: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)
:GetKeyK Ici, on dit que K est égal à la dernière touche enfoncée
: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,
:3E:19A on la met à la ligne 3, et A sera égal à 19 (nécessaire pour la flèche)
:Goto A:End Et on se rendra à l'étiquette A, en haut, pour placer la flèche en fonction de A
:E-1E:A+10A Sinon, si K est tout simplement égal à 25, alors on placera la flèche une ligne plus bas (A+10) et on le dira au programme (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:
:1E:39A Si la flèche était en bas, on la met en haut
:Goto A:End
:E+1E:A-10A et on change encore les valeurs de A et de E
: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),
:Disp "SALUT !" On écrira "SALUT"
: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 !

 

 

Prgm et Return :

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
:ClrHome D'abord, on efface l'écran comme tout bon début de programme.
: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" !!!) :

ex : DISCIPLE :

:ClrHome Une fois dans le programme disciple, on efface l'écran pour que ce soit plus beau

:For(A,1,16) On met plein de petits points partout, sur les lignes (enfin, juste en bas et en haut)
:Output(1,A"." En haut,
:Output(8,A,"." comme en bas (/!\ Attention ! Pour mettre ces points, il faut aller dans [2nd] [Y=] [<<] [3] /!\)
:End

:For (A,2,7) On recommence pour mettre des points sur les colonnes
:Output(A,1,"." à gauche,
:Output(A,16,"." comme à droite !
:End

:Output(3,3,"prgm tiré du"
:Output(4,3,"tutoriel du" On écrit, entre le magnifique cadre, d'où vient ce magnifique tutoriel :o)
:Output(6,4,"Site de"
:Output(7,5,"Yannick"

:For(A,2,16) Et là, on remplace les petits points par des points normaux (ceux à côté du 0)
:Output(1,A,"." Ici, on met les "gros" points
:Output(1,A-1,"." Et dans la "case" précédente (A-1), on remet un point "fin"
:For(B,1,50) Ici, on rajoute une boucle pour ralentir le tout, sinon on ne voit rien
:End:End Et là, on termine les deux boucles, en séparant les instructions par un double point.

:For(A,2,8)
:Output(A,16,"."
:Output(A-1,16,"." On répète la même chose dans la colonne de droite (avant, c'était la ligne du haut)
:For(B,1,50)
:End:End

:For(A,15,1,-1)
:Output(1,A,"."
:Output(1,A+1,"." On répète encore dans la ligne du bas (vous remarquerez le A+1 car on va en sens inverse, droite vers gauche)
:For(B,1,50)
:End:End

:For(A,7,1,-1)
:Output(A,16,"."
:Output(A+1,16,"." Et on fait encore ça à gauche !
:For(B,1,50)
:End:End

:Return Une fois que le gros point a fait le tour du cadre, on peut utiliser l'instruction "return" pour revenir au programme BASE, en rouge, en dessous :

:ClrHome Une fois qu'on est revenu dans le programme disciple, on efface à nouveau l'écran
:Disp "Voilà !"
:Disp "Tu as vu le"
: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.

Stop :

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)A Et on génère la note, comprise entre 1 et 20 et enregistrée sous le nom de A

: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)A On refait donc le tirage aléatoire,

: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 "VOUS AVEZ ENTRE"
: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 !!!

:Lbl 10 Et ici...
: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 :

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. :

:0A D'abord, on donne la valeur de 0 à A
:ClrDraw On efface les dessins
:-1Xmin
:-1Ymin
:2Xmax On prépare les dimensions de la fenêtre (dans "Vars")
:2Ymax
:AxesOn Et on active les axes

:"X"Y1 On donne la formule de le première fonction : Y=X
:"X2"Y2 Et celle de la deuxième fonction : Y=X²
: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.5Xmin
:0.5Ymin
:1.5Xmax Après la Pause, on détermine de nouvelles valeur pour les dimensions de la fenêtre
:1.5Ymax
:1A Et on donne une valeur à A (pour qu'il ne soit pas égal à 0)

: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.