L'Axe Parser
L'Axe Parser se résume à deux choses : facilité d'utilisation et rapidité.
A la fin de ce tuto, vous serez en mesure de :
- Dessiner des sprites.
- Manipuler des variables propre à la calculatrice (comme les appvars, les Pic, ...etc).
- Faire des jeux multijoueurs via un câble.
- Faire apparaitre 3 niveaux de gris ou 4 niveaux de gris.
- Faire sortir du son sur des écouteurs.
- Gérer le multi-touche.
- Gérer le réglage du contraste.
- et bien plus encore...
Le tout à la même vitesse que n'importe que programme fait en ASM.
Ce cours est composé des parties suivantes :
-
Partie 1 : Les débuts
Bon, oui j'ai dit que l'Axe Parser est simple d'utilisation, cependant, pour que cela paraîsse ainsi, il faut des bases.. et je n'ai jamais dit que ces bases étaient simples à apprendre =).
Ici vous avez principalement vu les bases nécessaires pour faire tourner tout programme. Elles sont souvent similaires entre chaque langage de programmation. Seulement, ces langages ont chacun leurs particularités (nous verrons celles de l'Axe Parser dans la partie suivante). Néanmoins avant d'y aller tout de suite, relisez bien cette partie, vérifiez que vous avez tout saisi, faites des petits programmes pour vous entraîner, retenez votre respiration.. et direction la prochaine partie ==> [].
-
Partie 2 : Programmation avancé
Dans Cette partie nous étudierons les bases propres à l'Axe Parser. La difficulté de ce chapitre est un cran plus élevé que le chapitre précèdent, il est donc nécessaire de lire attentivement chaque chapitre et de s'entraîner (c'est comme cela que vous apprendrez). Sur ce allons y !
Maintenant vous êtes rodé comme jamais contre tous programmes en Axe Parser, je vous conseil de lire l'annexe une dernière fois, et partez pour créer le meilleur de vous même.
-
Partie 3 : Annexe
Ici, toutes les commandes, le vocabulaire, des exemples de fonctions,.. bref tout ce qu'il faut mettre en annexe
Vous ne connaîtrez peut être jamais cette annexe par cœur, donc j'essaierais de créer une version hors ligne de celle ci pour que vous puissiez programmer partout (même la ou il n'y a pas internet).
Partie 1 : Les débuts
Bon, oui j'ai dit que l'Axe Parser est simple d'utilisation, cependant, pour que cela paraîsse ainsi, il faut des bases.. et je n'ai jamais dit que ces bases étaient simples à apprendre =).
Information et installation
Tout d'abord, il faut savoir que l'on peut coder en Axe Parser uniquement sur les calculatrices z80 munies de mémoire flash (ROM), qui sont :
- Ti 83+(SE)
- Ti 84+(SE)
- Et toutes les autres calculatrices émulant les précédentes bien sur (TI-Nspire non-CAS notamment)
Mais si ma calculatrice n'est pas un de ces modèles, ça veut dire que je ne peux vraiment rien faire avec l'Axe Parser ?
Non, il est encore possible de développer ses programmes à partir d'émulateurs, et dans tout les cas il est possible d'exécuter un programme Axe Parser sur une calculatrice muni d'un processeur z80.
Les avantages
(Traduction du tableau original de la documentation)
|
TI-Basic |
xLIB/Celtic |
BBC Basic |
Asm z80 |
Axe Parser |
Difficulté du langage |
Facile |
Facile |
Moyen |
Difficile |
Moyen |
Vitesse |
Lent |
Moyen |
Rapide |
Très rapide |
Très rapide |
Éditable sur la calculatrice? |
Oui |
Oui |
Avec un éditeur spéciale |
Pas raisonnablement |
Oui |
Exécution |
Interprété |
Interprété |
Interprété |
Compilé |
Compilé |
Support des sprites ? |
Non |
Oui |
Oui |
Oui |
Oui |
Variable nécessaire pour être exécuté |
Pic, Lists, Strings,...etc |
Pareil qu'en Basic avec
16kb d'application en plus |
49kb d'application |
Aucun |
Aucun |
Compatible avec les shells ? |
Oui |
Quelques |
Aucun |
Oui |
Oui |
Spécialité |
Math |
Jeux |
Varié |
Tout |
Jeux |
Voir le code source |
Toujours |
Toujours |
Toujours |
Optionnel |
Optionnel |
Il n'y a pas de langage de programmation parfait, chacun a des avantages et inconvénients. C'est à vous de décider ce qui convient le mieux à vos besoins. Si vos priorités sont la rapidité, la facilité d'utilisation, et la capacité de faire beaucoup de choses, alors l'Axe Parser est fait pour vous.
Les inconvénients
En Axe, on a des possibilités qu'aucun autre langage de programmation sur z80 ne donne accès aussi facilement.
Malheureusement, à chaque bon côté en Axe, il y a mauvais côté (bon ok, il y a quand même plus de bons cotés

). Le problème le plus courant est qu'à la moindre erreur de code vous risquez le ram cleared ou le freeze de la calculatrice.
Il est même possible de corrompre la mémoire flash de la calculatrice.
Ici on peut admirer un magnifique ram cleared sur une TI 84+SE (tout ce qu'il y a de plus classique).
Ici on a affaire à deux variables Pic1, un prodige que seul l'Axe Parser peut expliquer
Pour cette raison, il est recommandé de bien sauvegarder vos codes sources sur un ordinateur en cas de problèmes.
Autre chose encore : un programme écrit en Axe Parser sera environ 1.5 à 2 fois plus grand qu'un même programme écrit en asm z80.
Les outils
Tout d'abord il faut télécharger la dernière mise à jour :
ici
Dézippez le fichier zip.
Puis on va un peu décortiquer de quoi il est composé :
- Un dossier Developers
- Un dossier Examples
- Un dossier Tools
- Un fichier ACTUALLY READ ME.txt
- Un fichier Auto Opts.txt
- Un fichier Axe.8xk
- Un fichier ChangeLog.txt
- Un fichier Commands.htm
- Un fichier Documentation.pdf
- Un fichier keycodes.png
Ce dont on va avoir besoin pour l'instant est le fichier
Axe.8xk. Mettez le sur votre calculatrice.
Euh.. comment je peut mettre un fichier de mon ordi sur ma calculatrice?
Sois vous regardez la documentation que vous avez récupérez lors de l'achat de votre TI, soit je vous conseil de regarder le tuto sur l'utilisation de TI-connect fait par Mic, l'administrateur du site TI-Bank :
ici
Ok, j'ai réussi à mettre Axe.8xk.. et maintenant ?
Maintenant il vous suffit d'aller dans le menu des applications

, puis vous verrez
Axe de rajouté dans la liste, démarrez le, et vous devriez voir ça :
Pour se déplacer dans les menus de l'application, on utilisera les flèches

, pour sélectionner on utilisera

ou

et pour quitter ou revenir au menu précédent on peut utilisé

ou

Maintenant nous allons nous intéresser aux réglages. Allez dans
option, et là un sous-menu apparaît :
Shell : Permet de choisir pour quel shell on compilera le programme source, on peut soit mettre :
- no shell : Compilera pour aucun shell, le programme s'exécutera via la commande Asm(prgmMONPROG
- Ion : compilera le programme pour Ion.
- Mirage OS : compilera le programme pour Mirage OS.
- Doors CS : compilera le programme pour Doors CS.
- Application : compilera le programme sous forme d'application.
Alpha : Permet d'activer ou non les minuscules (lowercase en anglais).
Safety : Permet de sauver le code source lors de la compilation en cas d'éventuels bugs du programme (très utile ! ).
Back : Retour au menu principal
Qu'est ce qu'un shell ?
Un shell est un programme ou une application ayant une interface amélioré pour démarrer des programmes ASM prévus pour ce shell (certain ont plus ou moins de compatibilités avec d'autre type de programme ASM). Ici les programmes seront compilés à peu près comme pour l'ASM, donc on laisse le choix du type de shell.
Maintenant retournez dans le menu principal, puis allez dans
compile, pour l'instant vous n'avez peut être aucun programme affiché, mais il peut y en avoir de 2 sortes :
- Le premier est un source basique prête à être compilée.
- Le deuxième est une sauvegarde de source, il sera signalé par le symbole dièse # devant lui.
Notion de compilation
"Compilation", "compiler", on ne parle que de ça, mais qu'est ce que c'est?
Eh bien on a vu plus haut que les programmes sur la TI peuvent être soit "interprété", soit "compilé".
Un programme est interprété quand la calculatrice lit, ligne par ligne, le code source du programme, l'interprète en langage machine et l'exécute en même temps. C'est le cas du Ti-Basic.
En revanche, un programme est compilé lorsque le code source est préalablement transformée en langage machine, afin d'être directement exécuté par la TI. La calculatrice n'a plus besoin de lire ligne par ligne votre code pour l'interpréter et ensuite l'exécuter ; un programme compilé est donc bien plus rapide !
Bon, rien de compliqué jusqu'ici, nous verrons l'utilité du contenu du reste fichier zip plus tard, mais je ne vous interdis pas de le regarder
Mon premier programme
Maintenant que vous avez bien réglé vos options préférées on va voir comment programmer en Axe Parser (enfin !

). Pour cela il faut créer notre programme source, qui ensuite sera compilé en un programme exécutable (via l'application que l'on vient de mettre).
Créer le source
Créez un nouveau programme

, puis indiquez le nom de votre
programme source. Ensuite sur la première ligne de ce programme, mettez un point suivi du nom de votre
programme exécutable :
Code : Axe Parser - Sélectionner1
2
| PROGRAM:AXESOURCE
:.AXEEXECUTABLE |
Ici j'ai créé le programme AXESOURCE et lorsqu'il compilera il créera AXEEXECUTABLE.
A partir de maintenant, votre programme est visible et compilable dans le menu de compilation de l'application vue précédemment, mais il faut aussi savoir que certaines commandes de l'Axe Parser sont des commandes de base dont le nom a été modifié, par exemple si vous appuyez sur la touche , vous verrez ►Char à la place de ►Frac
Afficher du texte
Commençons par ce qu'il y a de plus simple, écrire du texte.
Il existe 4 commandes pour afficher du texte en Axe Parser, celles-ci sont très similaires au TI-Basic mais ne vous fiez pas aux apparences :
- La commande
Disp
Code : Axe Parser - Sélectionner
Avantage : saute les lignes automatiquement.
Inconvénient : pas très pratique si l'on veut mettre une lettre en bas à droite de l'écran.
- La commande
Text
Code : Axe Parser - Sélectionner
Avantage : supporte les différentes tailles de police via une commande "Fix" (j'y reviendrais plus tard).
Inconvénient : on ne peut pas placer le texte n'importe ou et on ne saute pas les ligne.s
- La commande
Output(
Code : Axe Parser - Sélectionner
Avantage : ici on peut placer à un point donné notre texte.
Inconvénient : ne fait pas tout ce que fait la commande suivante
Le X et le Y seront ici des nombres entre 0 et 16 pour X, et 0 et 8 pour Y. Cette commande est l'équivalente du output en TI-Basic.
- La commande
Text(
Code : Axe Parser - Sélectionner
Avantage : supporte les différentes tailles de police via une commande Fix et on peut le mettre n'importe ou dans sur l'écran.
Inconvénient : on ne saute pas les lignes (C'est si grave que ça ?

).
Le X et le Y seront ici des nombres entre 0 et 96 pour X, et 0 et 64 pour Y. Cette commande est l'équivalente du Text( en TI-Basic, le texte sera placé en fonction des pixels de la calculatrice.
Donc je récapitule, je veux écrire "MONTEXTE" :
Code : Axe Parser - Sélectionner1
2
| :.MONPROGRAMME
:Text(0,0,"MONTEXT |
J'utiliserais cette dernière commande le plus souvent, mais toutes les commandes ont une raison d'être, donc en fonction des situations n'hésitez pas à varier !
Vous remarquerez que le " et la ) disparaissent à la fin de la ligne, on peut donc écrire aussi bien Text(X,Y,"MONTEXTE") que Text(X,Y,"MONTEXTE, c'est en fonction de vos préférences
J'ai compilé et démarré mon programme, mais il n'a rien affiché.
Oui, c'est possible, surtout si vous utilisez un shell (comme MirageOS ou Ion), cela vient du fait que le programme a affiché le texte, mais qu'il s'est ensuite éteint, il faut donc mettre une pause.
Faire un pause
J'ai fait une pause, mon programme a fait apparaître le texte comme il faut, mais la calculatrice s'est freezée et il a fallu que j'enlève les piles
Rah.. vous pouviez pas attendre que j'explique?
Donc, je disais qu'il fallait faire une pause pour nous laissé le temps de voir, seulement la commande Pause utilisez en TI-Basic n'a pas la même utilisation que pour l'Axe Parser!
La commande Pause se trouve ici :
Pour faire simple, la pause de l'Axe Parser se compte en millisecondes, et le nombre de millisecondes doit être au
minimum de 1, donc les codes suivant ne sont pas bons :
Code : Pas bien - Sélectionner
Code : Pas bien - Sélectionner
Et pour que ce soit visible on fera des pauses de 1 seconde par exemple :
Code : Axe Parser - Sélectionner1
2
| :Pause 1000
:.car 1000 millisecondes = 1 secondes |
Comme dans tous langage qui se respecte, l'Axe Parser possède une commande pour inclure des commentaire dans le texte. Elle se traduit par un . en début de n'importe quel ligne, sauf la première.
Cette première partie n'est pas très compliquée, je vous donne là quelque commandes élémentaires qui vous permettront de faire une meilleur mise en texte pour vos futur programmes.
Variables et calculs
Une variable est une valeur que l'on peut modifier durant un programme. Celle-ci est enregistrée dans un endroit très précis dans la calculatrice que l'on verra plus loin dans le cours. Bref, dans tout langage de programmation il y a des variables, on ne peut pas y échapper.
Les variables et quelques notions de mathématiques
Des maths ? je peux m'en aller?
Ahah je vous ai enfin piégé
Mais non ne vous inquiétez pas, ce ne sera pas bien compliqué

, il est nécessaire de comprendre quelques notions pour la suite des choses, donc autant s'y attaquer dès le début !
Pour définir une variable, rien de plus simple :
Code : Axe Parser - Sélectionner
Ici on a donné 0 comme valeur à la variable A.
Maintenant je veux donner 0 aux variable A et B :
Code : Axe Parser - Sélectionner
Vous avez remarqué qu'il n'est pas nécessaire de réécrire à chaque fois la valeur 0, mais on peut faire mieux encore, si je veut donner comme valeur 4 à A et 8 à B :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
| :4→A+4→B
:.Ou encore
:4→A*2→B
:.Dans le même genre
:8→B/2→A
:8→B-4→A |
Jusque là ça va, non?
Maintenant si je veux faire respectivement une addition, une soustraction, une multiplication, une division et un modulo :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
| :1+1→A
:.A=2
:2-1→A
:.A=1
:2*2→A
:.A=4
:5/5→A
:.A=1
:4^3→A
:.A=1 |
Modulo?

kesako?
Le modulo est une opération mathématique qui permet d'obtenir le reste d'une division euclidienne, donc ici 4/3 = 3*1+1, reste 1.
Maintenant on vas voir quelque opérations plus complexe, et toujours utiles à savoir :
La valeur absolue :
Code : Axe Parser - Sélectionner1
2
| :abs(A)→A
:.Si A est négatif, il devient positif |
Le maximum des deux expressions :
Code : Axe Parser - Sélectionner1
2
3
| :12→A+6→B
:max(A,B)→C
:.Ici C=B car B=18 |
Le minimum des deux expressions :
Code : Axe Parser - Sélectionner1
2
3
| :12→A+6→B
:min(A,B)→C
:.Ici C=A car C=12 |
Le carré de l'expression :
Code : Axe Parser - Sélectionner1
2
3
| :3→A
:A²→A
:.A est égale à 9 |
La racine de l'expression :
Code : Axe Parser - Sélectionner
Dans les calculs en Axe Parser, il n'y a aucune règle de priorité !
En effet, lorsque l'on fait le calcul 1+1*2 sur sa calculatrice, on obtient 3, mais en Axe on obtiendra 4 !
D'où vient le problème?
En fait il lit le calcul comme il vient, sans prendre compte des règles de priorités... SAUF des parenthèses.
Donc 1+1*2 donnera 1+(1*2) en Axe Parser, mais le plus simple reste d'organiser son calcul comme cela : 1*2+1
Notions de booléens
Encore du calcul ? AAAargh..
Oui encore du calcul, mais celui ci est plus simple à comprendre, car il n'y a que 2 résultats possibles dans un calcul booléen :
0 (on dira que c'est FAUX)
1 (on dira que c'est VRAI)
Cette étape est très importante pour comprendre les chapitres suivants.
Donc, commençons par un exemple de booléen très simple :
Code : Axe Parser - Sélectionner1
2
3
| :2→A+1→B
:A=B→C
:.C est égale à 0 car A n'est pas égale à B |
Maintenant avec d'autre symboles :
- Strictement inférieur
Code : Axe Parser - Sélectionner1
2
3
| :2→A+8→B
:A<B→C
:.C est égale à 1 car A est plus petit que B |
- Strictement supérieur
Code : Axe Parser - Sélectionner1
2
3
| :2→A+8→B
:A>B→C
:.C est égale à 0 car A n'est pas plus grand que B |
- Inférieur ou égale
Code : Axe Parser - Sélectionner1
2
3
4
5
6
| :5→A→B
:4→D
:A≤B→C
:.C est égal à 1 car A est égal à B
:D≤B→C
:.C est égal à 1 car D est plus petit que B |
- Supérieur ou égal
Code : Axe Parser - Sélectionner1
2
3
4
5
6
| :5→A→B
:4→D
:A≥B→C
:.C est égale à 1 car A est égal à B
:D≥B→C
:.C est égale à 0 car D n'est pas plus grand que B |
Maintenant on va rajouter des opérateurs logiques.
Euh.. c'est quoi ça?
Un opérateur logique est un moyen de comparer plusieurs expression, par exemple :
Tout cela paraît compliqué, mais en réalité c'est de la logique appliquée avec des 0 et des 1
Exercice
Ce n'est pas le tout de lire, mais pour comprendre il n'y a pas meilleur moyen que de pratiquer.
L'exercice ici vas être d'afficher 0 quand A est VRAI, et 1 quand A est FAUX avec
un seul calcul. Vos deux résultats seront affichés une seconde au centre de l'écran à peu près.
Euh.. afficher un variable?
Oui, je ne vous ai pas encore donné la commande pour afficher une variable. Il suffit de mettre la variable
sans guillemets suivi de la commande ►Dec, par exemple pour afficher la variable A avec la commande Disp :
Code : Autre - Sélectionner
donc je récapitule :
Code : Autre - Sélectionner1
2
3
4
5
6
7
8
9
| :0→A
:Calcul→A
:.A sera égal à 1
:Afficher A vers le milieu de l'écran
:Attendre le temps d'une seconde
:Même calcul→A
:.A sera égale à 0
:Afficher A une ligne en dessous de la première réponse (toujours vers le centre de l'écran)
:Attendre une seconde encore |
Résultat
Maintenant que vous avez bien cherché et bien trouvé le résultat

, je vais vous montrer les possibilités qu'il s'offraient à vous :
Secret (cliquez pour afficher)
Tous d'abord le principal code sans le calcul :
Code : Autre - Sélectionner1
2
3
4
5
6
7
| :0→A
:Calcule→A
:output(8,4,A►Dec
:Pause 1000
:Même calcul→A
:output(8,5,A►Dec
:Pause 1000 |
La Pause 1000 pour une seconde et la commande
output( car elle sera plus facile à utiliser que
Text( dans ce cas (il suffit de rajouter 1 à l'axe Y pour sauter une ligne).
Ensuite le calcul, on pouvait soit faire avec un symbole :
Code : Autre - Sélectionner1
2
3
| :A<1→A
:.ou encore
:A>0→A |
Mais on pouvait également faire par une astuce de calcul :
Code : Autre - Sélectionner
Quand A est égale à 1, le calcule fait 1-1=0. Quand A est égale à 0, le calcule fait 1-0=1.
Donc voici le code final :
Secret (cliquez pour afficher)
Code : Autre - Sélectionner1
2
3
4
5
6
7
| :0→A
:1-A→A
:output(8,4,A►Dec
:Pause 1000
:1-A→A
:output(8,5,A►Dec
:Pause 1000 |
Relisez bien ce chapitre, c'est sûrement le plus difficile à comprendre pour cette première partie, mais une fois que vous aurez comprit l'intérêt des variables et des booléens, vous aurez les bases nécessaires pour apprendre tout langage de programmation, dont l'Axe Parser

.
Les conditions
On retrouve les conditions dans beaucoup de langages, mais qu'est ce que les conditions?
C'est ce que nous allons essayer de comprendre durant ce chapitre.
Explication de la condition
Une condition sert à tester une variable. Dans votre vie de tous les jours vous êtes confronté à de nombreuses conditions, plus ou moins sympathiques, par exemple :
CitationSi j'ai donné deux euros à la boulangère, alors j'ai du pain.
Ou encore :
CitationSi je n'ai pas un donné deux euros à la boulangère, alors je n'ai pas de pain.
Cette deuxième condition vas être une conséquence de la première et vice versa.
Donc dans un programme de jeu ça pourrait donner :
Code : Algorithme - Sélectionner1
2
| Si je meurs
Alors j'ai perdu la partie |
Ici en Axe Parser avec V qui est égal à 1 s'il reste une vie, ou V est égal à 0 s'il ne reste aucune vie :
Code : Axe Parser - Sélectionner1
2
3
| :If V=0
:Disp "Game Over"
:End |
Si l'on examine ce code avec précision :
Code : Axe Parser - Sélectionner
S'il n'y a plus de vie.
Code : Axe Parser - Sélectionner
On affiche
Game Over.
Code : Axe Parser - Sélectionner
Toute structure conditionnelle se termine par un End. Celui ci est présent pour signaler à notre programme que notre condition est terminé, et que le code reprend son cours normal. Si il n'y a pas de End, ou qu'il y a un End en trop, vous aurez une erreur
ERR:BLOCK lors de la compilation.
"V=0" ? ça ressemble drôlement à des booléens !
C'est là que je voulais en venir, le principal intérêt sera d'utiliser des booléens dans des conditions, et croyez moi ça facilite vraiment la vie!
Les conditions ; si, sinon, ou sinon.
On a vue précédemment les conditions les plus courtes :
Code : Axe Parser - Sélectionner1
2
3
4
| :If (maCondition)
:.le code à exécuter
:End
:.toujours terminer par un End! |
Note : maCondition sera donc une opération booléenne!
Maintenant, si l'on veut exécuter un code quand la condition est vraie, et un autre quand est est fausse, on utilisera Else de la façon suivante :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :If (maCondition)
:.le code à exécuter si la condition est VRAI
:Else
:.sinon on exécute le code suivant
:."code suivant"
:End
:.(on oublie pas le End) |
Mais mon code va vite fait se remplir de If, Else et End !
Oui! C'est un programme!
Mais je vous rassure, on peut organiser ses conditions, grâce à une autre commande : ElseIf
Elseif sera utilisé comme ceci :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
| :If (maPremièreCondition)
:.le code à exécuter si la condition est vraie
:Elseif (maDeuxièmeCondition)
:.sinon si la deuxième condition est vraie, on exécute le code suivant
:."code suivant"
:Else
:.sinon ce code est exécuté.
:End |
Par exemple je reprend notre système de vie :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :If V=0
:Disp "Game over"
:Elseif V=1
:Disp "Il ne vous reste plus qu'une vie !"
:Else
:Disp "Vous êtes en parfaite santé"
:End |
Bon, jusque la ce n'est pas trop compliqué? j'espère que non, car maintenant on va rajouter les calculs booléens (que vous maitrisez parfaitement

) dans ces conditions.
La puissance des conditions prend tout son ampleur lorsqu'on la mélange avec les tests logiques que l'on a vu précédemment :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| :If A=0
:.Mon code
:End
:If A≠0
:.Mon code
:End
:If A<0
:.Mon code
:End
:If A>0
:.Mon code
:End
:If A≥0
:.Mon code
:End
:If A≤0
:.Mon code
:End |
Puis les comparateurs logiques :
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
| :If (A=0) and (B≠8)
:.Mon code
:End
:If (A<0) or (B>8)
:.Mon code
:End
:If (A≥0) xor (B≤8)
:.Mon code (ne sera jamais exécuté ici)
:End |
Ici on a vu les conditions les plus simples à comprendre. Mais grâce aux booléens, on peut simplifier l'écriture suivante :
Code : Axe Parser - Sélectionner1
2
3
| :If A=1
:.le code s'exécutera si A est VRAI
:End |
En celle ci :
Code : Axe Parser - Sélectionner1
2
3
| :If A
:.le code s'exécutera si A est VRAI
:End |
Ici, A s'exécutera si il est plus grand ou égale à 1
Et si A est négatif, il n'y a pas un moyen plus simple que If A≠0
Si il y existe les conditions inversé, j'allais en parler

.
Les conditions inverse
En faite, les conditions inversés sont exactement pareil que les conditions normale. On rajoutera juste le point d'exclamation
! :
Code : Axe Parser - Sélectionner1
2
3
| :!If A
:.Si A est FAUX, on exécute ce code
:End |
Il marchera donc pour toutes les variantes de la structure conditionnelle vu précédemment :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
| :!If (maCondition)
:.le code à exécuter si la condition est FAUX
:Else
:.sinon on exécute ce code
:End |
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :!If V
:Disp "Game over"
:Else!if V>1
:Disp "Il ne vous reste plus qu'une vie !"
:Else
:Disp "Vous êtes en parfaite santé"
:End |
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
| :!If (A=0) and (B≠8)
:.Mon code
:End
:!If (A<0) or (B>8)
:.Mon code
:End
:!If (A≥0) xor (B≤8)
:.Mon code (sera toujours exécuté ici)
:End |
Les conditions décrémentés
Ce type de condition est plus dur à comprendre car en plus de tester une conditions, il va agir sur la variable testé en la décrémentant de 1 à chaque fois qu'elle est testé. Quand cette variable atteint 0, elle est restitué à sa valeur maximum que l'on aura définie.
Code : Axe Parser - Sélectionner1
2
3
| :DS<(VARIABLE,VALEURMAXIMUM)
:.code1
:End |
Un exemple de conditions décrémentés :
Code : Axe Parser - Sélectionner
La première fois que la condition sera testé, X=3, comme X n'est pas égale à 0 on enlève 1 à X et le code1 est ignoré, la deuxième fois X=2, pareil on enlève 1 et on ignore code1, la troisième fois X=1, on enlève 1 et on ignore toujours le code1. La quatrième fois X=0, le code1 est exécuté, et X=3.
Mais comment cette condition peut être testé plusieurs fois dans le même code?
Cela tombe bien, c'est le sujet de notre prochain chapitre :
Les boucles.
Les boucles
Une boucle consiste à répéter un code tant qu'une condition ne s'applique pas.
Omniprésentes dans tout programme, les boucles se ressemblent à travers les langages, et l'on retrouve en Axe Parser les 3 principales boucles utilisées dans la plupart des langages :
- La boucle Repeat
- La boucle While
- La boucle For
La boucle Repeat
La boucle Repeat se traduit par : "
répéter jusqu'à ce que telle condition soit vraie"
Syntaxe :
Code : Axe Parser - Sélectionner1
2
3
4
| :Repeat condition
:.code à exécuter
:End
:.On n'oublie pas le End ! |
Le code exécuté sera répété tant que la boucle n'est pas terminée.
Par exemple, je veut répéter jusqu'à ce que le nombre de vie soit égal à 0 :
Code : Axe Parser - Sélectionner1
2
3
4
| :Repeat V=0
:.code à exécuter
:End
:Disp "PERDU!" |
Maintenant, imaginez le code pour faire un compteur, jusqu'à ce que V=0, avec un départ de 5 vie.
Non, pas trouvé ?
Bon OK je vous le donne :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
| :5→V
:Repeat V=0
:V-1→V
:End
:Disp "PERDU!" |
Et il n'y a pas, comme pour les conditions, un moyen plus simple d'exprimer V=0 (V est FAUX)?
Si, grâce à la boucle While
La boucle While
La boucle
While se traduit par : "
répéter tant que telle condition est vraie"
Syntaxe :
Code : Axe Parser - Sélectionner1
2
3
4
| :While condition
:.code à exécuter
:End
:.Toujours le End ! |
Contrairement au
Repeat, le code s'exécutera tant que la condition est vraie :
Code : Axe Parser - Sélectionner1
2
3
4
| :While V
:.code à exécuter
:End
:Disp "PERDU!" |
Et on reprend notre compteur de tout l'heure, mais en simplifié bien sur

:
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
| :5→V
:While V
:.Tant que V est plus grand que 0
:V-1→V
:End
:Disp "PERDU!" |
La boucle For
Bon, certes les boucles
Repeat et
While sont utiles, mais pour faire un compteur, rien de plus utile que la boucle
For(.
La syntaxe est la suivante :
Code : Axe Parser - Sélectionner1
2
3
4
| :For(Variable,ValeurInitiale,ValeurDeFinDeBoucle)
:.code à exécuter
:End
:.Et bien sur, le End. |
Une variable choisie va être initialisée à la valeur initiale, et la boucle vas être exécutée en incrémentant 1 à cette variable à chaque fois que le code est exécutée. Lorsque la boucle est terminée, la variable utilisée sera supprimée.
Dans un exemple concret ; je veux écrire le même texte mais en sautant une ligne à chaque fois, à l'aide de la commande
Output( :
Code : Axe Parser - Sélectionner1
2
3
| :For(A,0,7)
:Output(0,A,"Même texte
:End |
Maintenant avec la variable derrière, cela pourrait donner :
Code : Axe Parser - Sélectionner1
2
3
4
| :For(A,0,7)
:Output(0,A,"Choix")
:Output(6,A,A+1►Dec)
:End |
On aurait pu mettre le code suivant :Output(0,A,"Choix",A+1►Dec), cependant la variable vas être décalée de quelques colonnes par rapport au texte, et il est donc plus utile ici de détacher les commandes pour une meilleur mise en forme.
Ok, la boucle For( est pratique, mais à quoi servent les autres boucles alors ?
En faite la réponse se trouve dans le prochain chapitre, ou vous apprendrez à utiliser la commande
getKey.
Ce chapitre est très facile, mais entraînez vous et relisez le, il sera très utile pour la suite.
Le getKey
C'est bien beau, vous pouvez calculer pendant un programme, mettre des conditions, le faire tourner dans une boucle, afficher plein de choses à l'écran, etc.. Mais ça ne ressemble en rien à un jeu, pour l'instant on se contente de regarder notre programme.
Le but de ce chapitre est de vous apprendre à manipuler les getkey, fameuse commande qui repère si une touche est pressé, et l'assimiler à toutes les choses que l'on a vu jusque la.
Explication
La commande
getKey, comme en TI-Basic, repère si une touche à été pressé, on peut donc utiliser la même syntaxe qu'en TI-Basic :
Code : Axe Parser - Sélectionner
La commande
getKey se trouve ici :
Donc la variable K va contenir la valeur d'une touche pressé.
Mais comment savoir quelle valeur appartient à quelle touche ?
Souvenez vous ! Dans le dossier zip que vous avez téléchargé au début :
Citation
Je vous enlève la tache de double cliquer dessus pour voir l'image

:
Cela veut dire qu'à chaque fois que j'aurais besoin de la commande getKey, je devrais avoir sous la main cette image?
Non pas forcément, car si K est une simple valeur, on peut l'afficher !
Je vous laisse chercher comment faire

.

Après quelques secondes vous aurez trouvé ce code :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :.GETKEY
:0→K
:Repeat K
:getKey→K
:End
:Text(0,0,K►Dec
:Pause 2000 |
L'erreur ici serait d'afficher K dans la boucle, car quand aucune touche n'est pressé, K vaut 0, et il affichera toujours 0 si l'on ne s'en rend pas compte.
Mais on peut l'optimiser en utilisant dès maintenant la commande getkey :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
| :.GETKEY
:0→K
:Repeat K=15
:getKey→K
:If K
:Text(0,0,K►Dec
:End
:End |
Le programme affichera la dernière touche pressé, et s'éteindra quand la touche 15 aura été pressé :
Mieux encore,
getKey→K peut être mis directement au début de la boucle!
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
| :.GETKEY
:0→K
:Repeat getKey→K=15
:If K
:Text(0,0,K►Dec
:End
:End |
Le getKey en action
Hormis les codes touches différents, c'est exactement la même commande qu'en TI-Basic?
En faite il y a 2 commandes
getKey en Axe Parser, la première va retourner un nombre pour une touche qui aurait été pressé (voir plus haut). Et la deuxième va
retourner un booléen pour une touche précise.
Reprenons notre code pour les vies. Je veut que l'on quitte quand la touche

à été pressé :
Code : Axe Parser - Sélectionner1
2
3
| :Repeat getKey(15)
:.mon code de jeu.
:End |
L'avantage ? Déjà on a plus de variable à se trimballer

, et grâce à cette commande, on peut repérer si plusieurs touches on été pressés en même temps !
Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
| :Repeat getKey(15)
:If getKey(9) or getKey(54)
:.code
:End
:If getKey(33) and getKey(25)
:.code
:End
:End |
La commande getKey renverra 0 si la touche indiqué n'est pas pressé (FAUX), et 1 si elle l'est (VRAI)
Quoi? vous pensiez que c'était plus compliqué que cela?

Que nenni !
Exercice
Pour vous échauffer pour le prochain chapitre, je vais donner un petit exercice sur la commande
getKey.
Donc le but de l'exercice vas être de faire bouger la lettre 'O' à travers l'écran de la calculatrice en fonction des touches :

.
Le 'O' ne doit pas sortir de l'écran (96*64 je le rappelle).
Le programme se ferme en appuyant sur
J'en dit pas plus, à vos calto!
Résultat
Vous êtes sur d'avoir bien cherché?
D'abords, il fallait choisir la commande pour afficher la lettre 'O'. Le plus adapté ici est la commande
Text( car vu la rapidité de l'Axe Parser, vous n'auriez pas le temps de voir le 'O' se balader avec la commande
output(. Seulement, il y a une difficulté qui se pose ici ; en déplaçant le 'O', il va laisser des traces derrière lui en allant de gauche à droite et de bas en haut. Il fallait donc chercher une méthode plus ou moins efficaces. Je vous propose de mettre un espace avant le 'O' et d'en mettre 5 autres, 6 pixels en dessous des coordonnées normales (X,Y).
Donc en ajoutant la boucle qui se termine en appuyant sur

, on aura ce code :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
| :0→X→Y
:.On initialise les variable X et Y à 0 (X = largeur et Y = hauteur)
:
:Repeat getKey(15)
:.ici la boucle repeat sera préférable
:Text(X,Y+6," "
:Text(X,Y," O
:.code pour modifier X et Y
:End |
Bon, c'est un peu tiré par les cheveux je vous l'accorde. Mais si vous avez abandonné votre programme en rencontrant ce problème, retournez à votre calculatrice et revenez quand vous aurez vraiment fini

.
Maintenant, on doit modifier X et Y en fonction des touches directionnelles, sans oublier les "murs" virtuels :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
| :If getKey(2) and (X≠0
:X-1→X
:ElseIf getKey(3) and (X≠91
:X+1→X
:End
:If getKey(4) and (Y≠0
:Y-1→Y
:ElseIf getKey(1) and (Y≠58
:Y+1→Y
:End |
En tatonnant vous aurez surement trouvez les valeur 91 (pour la largeur) et 58 (pour la hauteur), qui correspondent à la place que prend la lettre 'O'.
Donc le code final :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| :0→X→Y
:.On initialise les variable X et Y à 0 (X = largeur et Y = hauteur)
:
:Repeat getKey(15)
:.ici la boucle repeat sera préférable
:Text(X,Y+6," "
:Text(X,Y," O
::If getKey(2) and (X≠0
:X-1→X
:ElseIf getKey(3) and (X≠91
:X+1→X
:End
:If getKey(4) and (Y≠0
:Y-1→Y
:ElseIf getKey(1) and (Y≠58
:Y+1→Y
:End
:End |
TP n°1 : la pluie de numéro
Pour ce dernier chapitre, je fait une pause, et je vous laisse travailler un peu

. Ce TP aura pour but de créer un jeu complet : la pluie de numéro.
Quelques consignes
Les commandes à connaitre
Mais comment effacer l'écran d'un coup ? comment créer un nombre aléatoire ?
J'allais vous le dire

.
Pour effacer l'écran, vous utiliserez la commande
ClrHome :

.
Pour créer un nombre aléatoire, il faudra utiliser la commande
rand. Celle-ci va créer un nombre aléatorie entre 0 et 65 535.

Mais comment faire pour que ce nombre soit entre 0 et 9 ?
C'est la qu'intervient le super modulo

, cette tache fait partie de ses spécialités :
Code : Axe Parser - Sélectionner
Et en simplifier :
Code : Axe Parser - Sélectionner
En faite, le reste de la division euclidienne de n'importe quel entier par 10, sera toujours comprit entre 0 et 9 (car 10 est divisible par 10), de même si je veut créer un nombre aléatoire entre 0 et 95 :
Code : Axe Parser - Sélectionner
Pour le reste vous savez faire (si si, je vous assure !

). Sur ce, prenez bien votre temps pour faire ce TP, (plusieurs jours/semaines si il faut), et lisez la suite
SEULEMENT quand vous aurez fini.
Mais n'hésitez pas à relire les chapitres précédents pour vous aider.
Correction
Après avoir amélioré votre programme mieux que je le ferais, vous venez ici pour voir ma modeste correction
Commençons par le commencement : il vous faut un menu qui réagisse en fonction des touches choisis.
Ici j'ai choisi la touche

pour jouer,

pour le crédit et

pour quitter :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| :.PLUIENUM
:.Le menu principale
:Repeat getKey(15)
:Text(20,10,"2nd : Jouer
:Text(20,20,"Alpha : Credits
:Text(20,30,"Clear : Quitter
:
:If getKey(54)
:.Mes fonctions de jeu
:End
:
:If getKey(48)
:.Le credit du jeu
:End
:End |
Il n'y a pas de suprise, tout ça a déjà été vu.
Les caractère avec accent (é, à, ê, ë, etc.) ne sont pas mis ici car la calculatrice ne les reconnais pas dans ce cas la.
Ensuite je fait mon crédit, qui revient au menu après avoir appuyer sur la touche

:
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
| :ClrHome
:Text(0,0,"Jeu Creer par
:Text(0,8,"Kindermoumoute
:Text(0,16,"Octobre 2010
:Text(0,30,"Merci a Wag1 pour la
:Text(0,38,"correction de ce tutoriel
:Repeat getKey(9)
:End
:ClrHome |
J'efface l'écran au début et à la fin de mon crédit, via la commande
ClrHome vu plus haut. Et j'attend que la touche

à été pressé avec une boucle avec rien dedans.
Passons aux choses serieuses.
D'abord, comment choisir un nombre aléatoire :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
| :!If T
:rand^10→N
:1→T
:End |
Il suffira de donner 0 comme valeur à T pour créer un nouveau nombre aléatoire (entre 0 et 9) dans la variable N (avec la commande
rand vu plus haut).
Ensuite, pour savoir si la touche pressé correspond avec ce nombre N, on peut faire :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
| :If getKey(33) and (N=0)
:1→I+S→S
:ElseIf getKey(34) and (N=1)
:1→I+S→S
[etc]
:Else getKey(20) and (N=9)
:1→I+S→S
:End |
Quand une touche correspond à N, on rajoute 1 à I (devient VRAI), puis met la valeur I+S (1+S) dans la variable S. La variable I va servir à initialiser le numéro, et la variable S va être la somme des points.
Cependant, comme vu dans le QCM précédent, on peut simplifier ce code :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
| :getKey(33) and (N=0)→I
:getKey(34) and (N=1)+I→I
:getKey(26) and (N=2)+I→I
:getKey(18) and (N=3)+I→I
:getKey(35) and (N=4)+I→I
:getKey(27) and (N=5)+I→I
:getKey(19) and (N=6)+I→I
:getKey(36) and (N=7)+I→I
:getKey(28) and (N=8)+I→I
:getKey(20) and (N=9)+I→I+S→S |
Comme N n'aura q'une valeur à chaque fois, il n'y a pas de risque que I sois égale à 2 ou plus.
Attention, il ne faut pas oublier le +I dans les calcules, ou sinon la variable I sera toujours remit à zéro la ligne suivante (sauf pour 9)
Et encore amélioré

:
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
| :(getKey(33) and (N=0)) or (getKey(34) and (N=1)) or (getKey(26) and (N=2)) or (getKey(18) and (N=3)) or (getKey(35) and (N=4)) or (getKey(27) and
(N=5)) or (getKey(19) and (N=6)) or (getKey(36) and (N=7)) or (getKey(28) and (N=8)) or (getKey(20) and (N=9))→I+S→S |
Ce code tiens sur une seule ligne !
Mais dans ce code il suffirait d'appuyer sur toutes le touches en même temps pour pulvériser les scores :p, donc je suis obligé de mettre un code antitriche :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
| :(getKey(33) xor getKey(34) xor getKey(35) xor getKey(36) xor getKey(26) xor getKey(27) xor getKey(28) xor getKey(18) xor getKey(19) xor getKey(20))
and ((getKey(33) and (N=0)) or (getKey(34) and (N=1)) or (getKey(26) and (N=2)) or (getKey(18) and (N=3)) or (getKey(35) and (N=4)) or (getKey(27) and
(N=5)) or (getKey(19) and (N=6)) or (getKey(36) and (N=7)) or (getKey(28) and (N=8)) or (getKey(20) and (N=9)))→I+S→S |
Le ou exclusif (
xor) va obliger qu'une seule touche sois pressé. Quand celui-ci retourne 1 (VRAI), on regarde si il y a également une touche correspondant à la valeur de N. Si il y en a une, alors I=1 (VRAI), et on incrémente S bien entendu.
On affiche N, qui descend de l'écran plus ou moins rapidement :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
| :Text(40,B,N►Dec
:Pause W
:B+1→B |
Maintenant, on va utiliser la variable I, qui détecte quand une touche correspond à N. Quand I est égale à 1, la vitesse du jeu doit augmenter, le numéro déjà à l'écran doit s'effacer, . :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
| :Text(40,B,N►Dec
:If I
:If W>1
:W-1→W
:End
:ClrHome
:0→I→T→B
:.T=0, on recréer un nombre aléatoire
:.B=0, N est affiché en haut de l'écran
:End
:Pause W
:B+1→B |
Toute la partie de jeu :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| :.On initialise nos variables (ici le temps W commence à 100 ms)
:0→I→T→B+100→W
:.On efface le menu précedent
:ClrHome
:
:.Le jeu commence, et s'arrête quand la lettre touche le bas de l'écran
:Repeat B=60 or getKey(15)
:.On choisi un nombre N aléatoire
:!If T
:rand^10→N
:1→T
:End
:.On affiche N en en fonction de B
:Text(40,B,N►Dec
:.On vérifie si la touche pressé correspond à N (avec un code anti-triche)
:(getKey(33) xor getKey(34) xor getKey(35) xor getKey(36) xor getKey(26) xor getKey(27) xor getKey(28) xor getKey(18) xor getKey(19) xor getKey(20)) and ((getKey(33) and (N=0)) or (getKey(34) and (N=1)) or (getKey(26) and (N=2)) or (getKey(18) and (N=3)) or (getKey(35) and (N=4)) or (getKey(27) and (N=5)) or (getKey(19) and (N=6)) or (getKey(36) and (N=7)) or (getKey(28) and (N=8)) or (getKey(20) and (N=9)))→I+S→S
:.Si sa correspond on initialise les variables, et le temps W diminue
:If I
:If W>1
:W-1→W
:End
:ClrHome
:0→I→T→B
:End
:
:Pause W
:B+1→B
:End
:.On efface l'écran
:ClrHome
:.Le score s'affiche dans le menu principale
:Text(0,0,"Score :
:Text(26,0,S►Dec |
Les ajouts possibles
Vous avez fini votre programme, mais deux forces en vous se combattent encore : Le
bien et le
mieux 
.
Ici je montrerais 3 amélioration pour rendre votre jeu un peu mieux (mais il n'y a jamais de limite dans les améliorations) :
- Faire une intro au début du programme (histoire de rendre le jeu dynamique).
L'intro que j'ai choisi de faire fait défiler le titre du jeu de gauche à droite, et fait apparaître très brièvement des tas de numéros sur l'écran

, mais ce n'est qu'un exemple, et vous êtes libre de faire l'intro que vous voulez :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
| :For(Z,0,60)
:ClrHome
:Text(Z,2," PLUIE
:Text(Z,10," DE
:Text(Z,18," NUMERO
:Text(rand^92,Z-(rand^45→B),rand^7→A►Dec
:Text(rand^92,Z+(B-5),A+1►Dec
:Text(rand^92,Z-(B+7),A+2►Dec
:Text(rand^92,Z+(B-7),A+3►Dec
:End
:ClrHome |
Lorsque l'on utilise la commande
ClrHome pour effacer l'écran constament dans une boucle, le bas de l'écran sera plus clair (gris clair) et le haut plus foncé (gris noir) lors de l'affichage du texte.
Pour limiter les rand (qui ralentissent fortement le programme), j'ai mis dans des variables temporaires B et A qui seront dans tous les cas initialisé par la suite.
- Faire apparaître les numéro à des endroits choisi au hasard.
Il suffit de rajouter une variable A lors de l'affichage du texte
Text(A,B,N►Dec qui sera choisi au hasard dans notre fonction déjà présente :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
| :!If T
:rand^10→N
:rand^92→A
:1→T
:End |
- Faire un mode difficile (en faisant défiler plusieurs numéro en même temps par exemple).
Dans mon exemple, il y a le niveau 0 (avec 1 numéro) et le niveau 1 (avec 2 numéro)
Le but va être de rajouter un deuxième numéro, sans que cela perturbe le premier code. On va donc être obliger de recopier le même code mais avec des noms de variables différentes. Il faudra que ce code soit pris en compte seulement lorsque le joueur l'a choisi (via un menu) :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
| :ClrHome
:Repeat getKey(9)
:Text(0,10,"Niveau :
:Text(28,10,L►Dec
:(getKey(4) and (L<1))-(getKey(1) and (L>0))+L→L
:End |
Bien sur vous êtes incollable sur l'incrémentation et la décrémentation, ce code n'a rien de difficile à vos yeux
Maintenant on reprend toutes les fonctions de notre premier code, mais avec d'autres variable, et seulement si il y a L :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| :Repeat Y=60 or (B=60) or getKey(15)
:...
:If L
:!If U
:rand^10→M
:rand^92→X
:1→U
:End
:End
:...
:If L
:Text(X,Y,M►Dec
:End
:If getKey(33) xor getKey(34) xor getKey(35) xor getKey(36) xor getKey(26) xor getKey(27) xor getKey(28) xor getKey(18) xor getKey(19) xor getKey(20)
:.Ici on laisse la condition, car ça raccourci le code, vu que l'on a 2 fois le code, mais avec N et devient M
:If L
:(getKey(33) and (M=0)) or (getKey(34) and (M=1)) or (getKey(26) and (M=2)) or (getKey(18) and (M=3)) or (getKey(35) and (M=4)) or (getKey(27) and (M=5)) or (getKey(19) and (M=6)) or (getKey(36) and (M=7)) or (getKey(28) and (M=8)) or (getKey(20) and (M=9))→J+S→S
:End
:End
:...
:If J
:If W>1
:W-1→W
:End
:ClrHome
:0→J→U→Y
:End
:...
:If L
:Y+1→Y
:End |
Le code final :
Secret (cliquez pour afficher)Code : Axe Parser - Sélectionner1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
| :.PLUIENUM
:
:.Une petite intro pour le fun
:For(Z,0,60)
:ClrHome
:Text(Z,2," PLUIE
:Text(Z,10," DE
:Text(Z,18," NUMERO
:Text(rand^92,Z-(rand^45→B),rand^7→A►Dec
:Text(rand^92,Z+(B-5),A+1►Dec
:Text(rand^92,Z-(B+7),A+2►Dec
:Text(rand^92,Z+(B-7),A+3►Dec
:End
:ClrHome
:0→S→I→J→T→U→A→B→X→Y+1→L→W
:
:.Le menu principale
:Repeat getKey(15)
:Text(20,10,"2nd : Jouer
:Text(20,20,"Alpha : Credits
:Text(20,30,"Clear : Quitter
:
:.Mes fonctions de jeu
:If getKey(54)
:ClrHome
:.Choix niveau
:Repeat getKey(9)
:Text(0,10,"Niveau :
:Text(28,10,L►Dec
:(getKey(4) and (L<1))-(getKey(1) and (L>0))+L→L
:End
:100→W
:0→S
:ClrHome
:
:Repeat Y=60 or (B=60) or getKey(15)
:!If T
:rand^10→N
:rand^92→A
:1→T
:End
:If L
:!If U
:rand^10→M
:rand^92→X
:1→U
:End
:End
:Text(A,B,N►Dec
:If L
:Text(X,Y,M►Dec
:End
:If getKey(33) xor getKey(34) xor getKey(35) xor getKey(36) xor getKey(26) xor getKey(27) xor getKey(28) xor getKey(18) xor getKey(19) xor getKey(20)
:(getKey(33) and (N=0)) or (getKey(34) and (N=1)) or (getKey(26) and (N=2)) or (getKey(18) and (N=3)) or (getKey(35) and (N=4)) or (getKey(27) and (N=5)) or (getKey(19) and (N=6)) or (getKey(36) and (N=7)) or (getKey(28) and (N=8)) or (getKey(20) and (N=9))→I+S→S
:If L
:(getKey(33) and (M=0)) or (getKey(34) and (M=1)) or (getKey(26) and (M=2)) or (getKey(18) and (M=3)) or (getKey(35) and (M=4)) or (getKey(27) and (M=5)) or (getKey(19) and (M=6)) or (getKey(36) and (M=7)) or (getKey(28) and (M=8)) or (getKey(20) and (M=9))→J+S→S
:End
:End
:If I
:If W>1
:W-1→W
:End
:ClrHome
:0→I→T→B
:End
:If J
:If W>1
:W-1→W
:End
:ClrHome
:0→J→U→Y
:End
:Pause W
:B+1→B
:If L
:Y+1→Y
:End
:End
:ClrHome
:Text(0,0,"Score :
:Text(26,0,S►Dec
:0→I→J→T→U→A→B→X→Y+1→L→W
:End
:
:.Le credit du jeu
:If getKey(48)
:ClrHome
:Text(0,0,"Jeu Creer par
:Text(0,8,"Kindermoumoute
:Text(0,16,"Octobre 2010
:Text(0,30,"Merci a Wag1 pour la
:Text(0,38,"correction de ce tutoriel
:Repeat getKey(9)
:End
:ClrHome
:End
:End |
Lien de téléchargement (source et exécutable) :
LIEN
Petit screenshot :
Pour ce chapitre, je vous passe de QCM (vous vous êtes déjà assez creusé les méninges

).
Je ne reparlerais pas de ce TP dans les chapitres suivant, néanmoins vous allez apprendre de nouvelles choses dans la prochaine partie (des tas de nouvelles chose

) qui pourront être utiliser dans ce programme pour l'optimiser encore plus, le rendre encore plus beau, plus rapide, plus jouable... (plus parfait?).
Je vous met l'eau à la bouche?
Bon OK, allez y

.
Ici vous avez principalement vu les bases nécessaires pour faire tourner tout programme. Elles sont souvent similaires entre chaque langage de programmation. Seulement, ces langages ont chacun leurs particularités (nous verrons celles de l'Axe Parser dans la partie suivante). Néanmoins avant d'y aller tout de suite, relisez bien cette partie, vérifiez que vous avez tout saisi, faites des petits programmes pour vous entraîner, retenez votre respiration.. et direction la prochaine partie ==> [].
Partie 2 : Programmation avancé
Dans Cette partie nous étudierons les bases propres à l'Axe Parser. La difficulté de ce chapitre est un cran plus élevé que le chapitre précèdent, il est donc nécessaire de lire attentivement chaque chapitre et de s'entraîner (c'est comme cela que vous apprendrez). Sur ce allons y !
Les pointeurs
La théorie
Vous devez comprendre les pointeurs ! Si vous n'avez jamais utilisé un langage de programmation utilisant les pointeurs avant, soyez très attentif. Les pointeurs sont des outils puissants et utiles que vous allez les utiliser dans pratiquement tous vos programmes. Ils permettent d'organiser la RAM.
Qu'est-ce que la RAM?
C'est de la mémoire vive, qui est alimenté par vos piles constamment, d'environ 65536 octets sur les TI-83+/84+.
Mais comment voulez-vous accéder à toutes cette RAM? Comment pouvez-vous lire et écrire dedans?
Par le moyen le plus simple ; donner à chaque octet de RAM ses propres adresse.
L'octet 0 a l'adresse 0, le octet 1 a l'adresse 1, et ce jusqu'au dernier octet 65535 de l'adresse 65535.
La pratique
Voici l'exemple le plus courant pour les chaînes de caractères :
Code : Autre - Sélectionner1
2
3
| :.HELLO
:"Hello World"→Str1
:Disp Str1 |
Mais c'est exactement pareil qu'en Basic
Faux!
Cela donne l'impression de fonctionner pareil. Regardons ce qui se passe réellement.
Tout d'abord, Str1 est un pointeur qui est un nombre, pas une réelle chaîne.
La phrase "Hello World" est stockée dans l'exécutable à une adresse et le pointeur Str1 est juste un nombre qui nous indique où cette chaîne se trouve dans le programme.
La fonction d'affichage prend un certain nombre comme argument, ensuite il faut que le pointeur trouve l'adresse qu'il pointe, et c'est comme cela qu'il sait où trouver la chaîne de caractère à afficher.
Un petit schéma pour éclaircir les choses :
*\
Todo
\*
Évolution possible
Mais si le pointeur est juste un nombre, on peut faire des maths avec?
Oui on peut faire des maths avec un pointeur! Observons ce code par exemple :
Code : Autre - Sélectionner1
2
3
| :.HELLO
:"Hello World"→Str1
:Disp Str1+6 |
Cela affichera juste "World", car la chaîne est stockée dans l'ordre dans des adresses. Disons : le "H" a été situé à l'adresse 100, donc "e" est à 101, le premier "l" est à 102, etc.. Donc, au moment où nous arrivons à l'adresse 106, nous sommes à "W". C'est pourquoi l'affichage de routine saute la partie "Hello".
En Axe, Str1 et les autres variables de la calculatrice sont appelés pointeurs statiques.
Cela signifie qu'une fois que vous les avez déclarés, leur valeur ne peut pas changer pour le reste du programme.
Les pointeurs statiques sont Str, Pic, et GDB. Vous pouvez les utiliser comme vous voulez, ce sont de simple numéros, mais c'est par convention qu'on utilise Str pour les chaînes de caractères (string), Pic pour les sprites, et GDB pour les Data. En aucun cas ce sont les variables utilisées en TI-Basic.
Qu'est ce que c'est que les sprites et les Data?

Pas maintenant, cela fera l'objet d'un prochain chapitre!
Les Data
*\
Todo
\*
Le Binaire et l'hexadécimal
*\
Todo
\*
Une histoire d'octels
*\
Todo
\*
Première sprite
*\
Todo
\*
*\
Todo
\*
Les listes
Maintenant vous êtes rodé comme jamais contre tous programmes en Axe Parser, je vous conseil de lire l'annexe une dernière fois, et partez pour créer le meilleur de vous même.
Partie 3 : Annexe
Ici, toutes les commandes, le vocabulaire, des exemples de fonctions,.. bref tout ce qu'il faut mettre en annexe
Commandes
Erreurs et vocabulaire
Les erreurs
ERR: LBL MISSING |
La fonction (ou le label) que vous appelé n'existe pas |
ERR: STACK FULL |
Il y a trop de parenthèse dans une même expression |
ERR: MAX SYMBOLS |
Il y a trop de pointeurs statique ou de label |
ERR: MAX SYMBOLS |
Le pointeur statique ou le label existe déjà |
ERR: BLOCK |
Regardez au niveau des End si il vous en manque un,
ou si vous en avez un en trop |
ERR: HEXIDECIMAL |
Le nombre hexadécimal est invalide |
ERR: BAD NUMBER |
Le nombre est trop grand ou trop petit |
ERR: BAD NAME |
Le nom attribué à un pointeur statique ou
à un label n'est pas correcte |
ERR: UNDEFINED |
Le pointeur statique utilisé n'existe pas |
ERR: OUT OF MEM |
La mémoire est pleine et le programme ne
peut pas être compilé |
ERR: BAD SYMBOL |
C'est l'erreur qui apparaît le plus
souvent. Sois une mauvaise commande a été utilisé, sois les
renseignement sont mauvaise pour une bonne commande, par exemple
un nombre à l'endroit ou l'on attend une variable. |
ERR: FILE NAME |
Le fichier de sortie est le même que
celui de votre source |
ERR: PIC MISSING |
L'image absorbé n'existe pas |
ERR: LOW BATTERY |
Vous ne pouvez pas archivé si la batterie est faible |
ERR: AXIOM |
Vous utilisez une version d'Axe corrompu |
ERR: ARGUMENT |
Vous avez un argument mauvais |
ERR: FILE MISUSE |
Vous avez incorrectement utilisé un ficher |
ERR: PARENTHESIS |
Une parenthèse est nécessaire pour mettre fin à cette commande |
ERR: NESTED LIBS |
Librairie indisponible. |
ERR: BAD PROGRAM |
La librairie que vous essayez d'ajouter n'est pas
un fichier Axe. |
ERR: UNKNOWN |
L'erreur est inconnu, reportez l'erreur immédiatement |
Vocabulaires
Des fonctions biens utiles
Repertoire de fonctions qui pouront vous servir
Vous ne connaîtrez peut être jamais cette annexe par cœur, donc j'essaierais de créer une version hors ligne de celle ci pour que vous puissiez programmer partout (même la ou il n'y a pas internet).
Voilà si vous avez bien tout lu vous êtes maintenant capable de faire l'impossible avec votre calculatrice!
Quelques liens pour faire partager vos projets ou poser des questions :
chez omnimaga,