> Le Site du Zéro > Cours > L'Axe Parser > Lecture du tutoriel

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

). 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 Image utilisateur

, puis vous verrez Axe de rajouté dans la liste, démarrez le, et vous devriez voir ça :

Image utilisateur

Pour se déplacer dans les menus de l'application, on utilisera les flèches Image utilisateur

, pour sélectionner on utilisera Image utilisateur

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

Maintenant nous allons nous intéresser aux réglages. Allez dans option, et là un sous-menu apparaît :

Image utilisateur

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 ? :euh:

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 ! :magicien:

). 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 Image utilisateur

, 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électionner

1 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 Image utilisateur

Code : Axe Parser - Sélectionner

1	:Disp "MONTEXT

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 Image utilisateur

Code : Axe Parser - Sélectionner

1	:Text "MONTEXT

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( Image utilisateur

Code : Axe Parser - Sélectionner

1	:output(X,Y,"MONTEXT

Avantage : ici on peut placer à un point donné notre texte.
Inconvénient : ne fait pas tout ce que fait la commande suivante :lol:

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( Image utilisateur

Code : Axe Parser - Sélectionner

1	:Text(X,Y,"MONTEXT

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 ? :euh:

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électionner

1 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? :diable:

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 : Image utilisateur

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

:Pause

Code : Pas bien - Sélectionner

:Pause 0

Et pour que ce soit visible on fera des pauses de 1 seconde par exemple :
Code : Axe Parser - Sélectionner

1 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é :pirate:

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

:0→A

Ici on a donné 0 comme valeur à la variable A.

→ apparaît en appuyant sur cette touche : Image utilisateur

Maintenant je veux donner 0 aux variable A et B :
Code : Axe Parser - Sélectionner

:0→A→B

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électionner

: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électionner

: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électionner

1 2	:abs(A)→A :.Si A est négatif, il devient positif

Le maximum des deux expressions :
Code : Axe Parser - Sélectionner

1
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électionner

1
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électionner

1
2
3

:3→A
:A²→A
:.A est égale à 9

La racine de l'expression :
Code : Axe Parser - Sélectionner

1
2
3

:9→A
:√(A)
:.A=3

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électionner

1
2
3

:2→A+1→B
:A=B→C
:.C est égale à 0 car A n'est pas égale à B

Note : le menu des symboles test "=, <, >, ≠, ≤, ≥" se trouve ici : Image utilisateur

Maintenant avec d'autre symboles :

Strictement inférieur
Code : Axe Parser - Sélectionner

1
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électionner

1
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électionner

: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électionner

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

and compare si les deux expressions sont vrai : EXP1 and EXP2
Code : Axe Parser - Sélectionner
1 2 3
:0→A→B :(A>6) and (B=A)→C :(A≤0) and (B=A)→D
EXP1 est égale à A>6 et EXP2 à B=A
A>6 est faux
B=A est vrai
Les deux expressions ne sont pas vrai, C=0.
A≤0 est vrai
B=A est vrai
Les deux expressions sont vraies donc D=1

Comme les expressions revoie 0 ou 1, on peut faire un tableau de toutes les réponses possible !

Ce tableau, appelé tableau de vérité, est le suivant pour l'opérateur and :

0 and 0 = 0
1 and 0 = 0
0 and 1 = 0
1 and 1 = 1

Un petit schéma pour expliquer le and :

En remplaçant les 2 cercles par 2 expression on peut mieux visualiser le and.
or cherche à savoir si au moins une expression est vraie : EXP1 or EXP2
Code : Axe Parser - Sélectionner
1 2 3
:0→A→B :(A>6) or (B=A)→C :(A≤0) or (B=A)→D
C est égal à 1 car la deuxième expression est vraie (B=A).
D est égal à 1 car les 2 expressions sont vraies.
Tableau de vérité :

0 or 0 = 0
1 or 0 = 1
0 or 1 = 1
1 or 1 = 1

Petit schéma :
xor cherche à savoir si et seulement si une seule des conditions est vraie :
Code : Axe Parser - Sélectionner
1 2 3
:0→A→B :(A>6) xor (B=A)→C :(A≤0) xor (B=A)→D
C est égale à 1 car la deuxième expression est vraie (B=A) et la première est fausse.
D est égale à 0 car ici les deux expressions sont vraie !
Tableau de vérité :

0 xor 0 = 0
1 xor 0 = 1
0 xor 1 = 1
1 xor 1 = 0

Et le schéma :

Tout cela paraît compliqué, mais en réalité c'est de la logique appliquée avec des 0 et des 1 :zorro:

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

1	:Disp A►Dec

donc je récapitule :
Code : Autre - Sélectionner

: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électionner

: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électionner

1
2
3

:A<1→A
:.ou encore
:A>0→A

Mais on pouvait également faire par une astuce de calcul :
Code : Autre - Sélectionner

:1-A→A

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électionner

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

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

Si j'ai donné deux euros à la boulangère, alors j'ai du pain.

Ou encore :
Citation

Si 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électionner

1 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électionner

1
2
3

:If V=0
:Disp "Game Over"
:End

Si l'on examine ce code avec précision :
Code : Axe Parser - Sélectionner

:If V=0

S'il n'y a plus de vie.
Code : Axe Parser - Sélectionner

1	:Disp "Game Over"

On affiche Game Over.
Code : Axe Parser - Sélectionner

:End

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.

On trouvera la commande If ici : Image utilisateur

Et la commande End là : Image utilisateur

"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électionner

: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électionner

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

On trouvera Else ici : Image utilisateur

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électionner

: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électionner

: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électionner

: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électionner

: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électionner

1
2
3

:If A=1
:.le code s'exécutera si A est VRAI
:End

En celle ci :
Code : Axe Parser - Sélectionner

1
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 ! : Image utilisateur

Code : Axe Parser - Sélectionner

1
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électionner

:!If (maCondition)
:.le code à exécuter si la condition est FAUX
:Else
:.sinon on exécute ce code
:End

Code : Axe Parser - Sélectionner

:!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électionner

:!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électionner

1
2
3

:DS<(VARIABLE,VALEURMAXIMUM) 
:.code1 
:End

La commande décrémenter DS< se trouve ici : Image utilisateur

Un exemple de conditions décrémentés :
Code : Axe Parser - Sélectionner

1
2
3

:DS<(X,3) 
:.code1 
:End

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? o_O

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électionner

:Repeat condition
:.code à exécuter
:End
:.On n'oublie pas le End !

Repeat se trouve ici : Image utilisateur

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électionner

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

Non, pas trouvé ?
Bon OK je vous le donne :
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

: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électionner

:While condition
:.code à exécuter
:End
:.Toujours le End !

While se trouve ici : Image utilisateur

Contrairement au Repeat, le code s'exécutera tant que la condition est vraie :
Code : Axe Parser - Sélectionner

: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électionner

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

On trouvera la boucle For( ici : Image utilisateur

La syntaxe est la suivante :
Code : Axe Parser - Sélectionner

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

On peut facilement recréer une boucle For( avec une boucle Repeat :
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

:ValeurInitiale→Variable
:Repeat Variable=ValeurDeFinDeBoucle
:.code à exécuter
:Variable+1→Variable
:End
:Delvar Variable

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électionner

1
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électionner

: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

:getKey→K

La commande getKey se trouve ici : Image utilisateur

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

Un fichier keycodes.png

Je vous enlève la tache de double cliquer dessus pour voir l'image :ange:

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électionner

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

:.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é : Image utilisateur

Mieux encore, getKey→K peut être mis directement au début de la boucle!
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

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

à été pressé :

Code : Axe Parser - Sélectionner

1
2
3

:Repeat getKey(15)
:.mon code de jeu.
:End

L'avantage ? Déjà on a plus de variable à se trimballer :lol:

, et grâce à cette commande, on peut repérer si plusieurs touches on été pressés en même temps !

Code : Axe Parser - Sélectionner

: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? :lol:

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 : Image utilisateur

.
Le 'O' ne doit pas sortir de l'écran (96*64 je le rappelle).
Le programme se ferme en appuyant sur Image utilisateur

J'en dit pas plus, à vos calto!

Résultat

Vous êtes sur d'avoir bien cherché? :zorro:

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 Image utilisateur

, on aura ce code :
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

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

.

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électionner

: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électionner

: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

Tout d'abord, le jeu doit démarrer sur un menu avec 3 choix :

Jouer ==> voir fonction jeu*
Crédits ==> Crédits donne des informations sur le créateur, année de création et les personnes remercié pour la création du jeu. Ces renseignements s'effaceront après avoir appuyer sur la touche .
Quitter ==> Quitter quitte le jeu.

*fonction jeu :
Le principe :
Des chiffres de 0 à 9 (choisi au hasard) tombent de l'écran (du haut vers le bas) et le joueur doit appuyer sur les touches correspondantes :
Image utilisateur

Lorsqu'un numéro a "touché" le bas de l'écran, le joueur a perdu, et on peu le lui dire

Bien sur n'importe quel joueur peut quitter à tout moment le jeu avec la touche : Image utilisateur

La vitesse du jeu doit être croissante, à chaque numéro trouvé par le joueur, la vitesse doit augmenter (attention n'oubliez pas de qu'il ne faut jamais se retrouver avec l'équivalent d'un Pause 0).

Quand vous aurez fait tout cela, on pourra encore faire quelques ajouts sympa, par exemple :

Faire un mode difficile (en faisant défiler plusieurs numéro en même temps par exemple).
Faire une intro au début du programme (histoire de rendre le jeu dynamique).
Faire apparaître les numéro à des endroits choisi au hasard.
Et tout ce que vous imaginerez d'autre.

Les commandes à connaitre

Mais comment effacer l'écran d'un coup ? comment créer un nombre aléatoire ?

J'allais vous le dire :ninja:

.

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

.

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.

La commande rand se trouve ici : Image utilisateur

Mais comment faire pour que ce nombre soit entre 0 et 9 ?

C'est la qu'intervient le super modulo :zorro:

, cette tache fait partie de ses spécialités :

Code : Axe Parser - Sélectionner

1 2	:rand→A :A^10→A

Et en simplifier :

Code : Axe Parser - Sélectionner

1	:rand^10→A

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

1	:rand^96→A

Pour le reste vous savez faire (si si, je vous assure ! :waw:

). 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 Image utilisateur

pour jouer, Image utilisateur

pour le crédit et Image utilisateur

pour quitter :

Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

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

:
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

: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 Image utilisateur

à été pressé avec une boucle avec rien dedans.

Code : Axe Parser - Sélectionner

1 2	:Repeat getKey(9) :End

Ce code est l'équivalent de la Pause du TI-Basic !

Passons aux choses serieuses.

D'abord, comment choisir un nombre aléatoire :
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

:!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électionner

: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électionner

: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é :magicien:

:
Secret (cliquez pour afficher)

Code : Axe Parser - Sélectionner

1
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électionner

1
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électionner

1
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électionner

: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électionner

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

.

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

, 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électionner

: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électionner

:!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) :soleil:

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électionner

: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électionner

: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électionner

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

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

) 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+. :euh:

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électionner

1
2
3

:.HELLO
:"Hello World"→Str1
:Disp Str1

Mais c'est exactement pareil qu'en Basic o_O

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électionner

1
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
\*

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,

^{Nouveau !} Rédigez des documents de qualité avec LaTeX
Reprenez le contrôle à l'aide de Linux
Clé USB du Site du Zéro 4 Go - 8 Go - 16 Go
C	PHP
Boutique

Boutique

Cours

L'Axe Parser

Informations sur le tutoriel

Publicité

Partie 1 : Les débuts

Partie 2 : Programmation avancé

Partie 3 : Annexe

Partie 1 : Les débuts

Information et installation

Les avantages

Les inconvénients

Les outils

Notion de compilation

Mon premier programme

Créer le source

Afficher du texte

Faire un pause

Variables et calculs

Les variables et quelques notions de mathématiques

Notions de booléens

Exercice

Résultat

Les conditions

Explication de la condition

Les conditions ; si, sinon, ou sinon.

Les conditions inverse

Les conditions décrémentés

Les boucles

La boucle Repeat

La boucle While

La boucle For

Le getKey

Explication

Le getKey en action

Exercice

Résultat

TP n°1 : la pluie de numéro

Quelques consignes

Les commandes à connaitre

Correction

Les ajouts possibles

Partie 2 : Programmation avancé

Les pointeurs

La théorie

La pratique

Évolution possible

Les Data

Le Binaire et l'hexadécimal

Une histoire d'octels

Première sprite

Les listes

Partie 3 : Annexe

Commandes

Erreurs et vocabulaire

Les erreurs

Vocabulaires

Des fonctions biens utiles

Informations sur le tutoriel