Tutoriel : L'Axe Parser

Présentation

La naissance d'un langage

Pour programmer sur calculatrice à processeur z80, il existe 2 langages officiels :

• Le TI-Basic : programmable sur la calculatrice (ou utilitaires PC). Ce langage est très simple à apprendre, mais la vitesse d'exécution des programmes TI-Basic est excessivement lente (pour les jeux en tous cas).

• L'Asm z80 : programmable sur calculatrice (depuis peu) et surtout à partir d'utilitaires PC. Ce langage est très compliqué à apprendre, pour un résultat beaucoup plus puissant qu'un programme TI-Basic.

La nécessité d'un troisième langage s'imposait. Plusieurs tentatives plus ou moins abouties existent (voir tableau plus bas), mais celle qui ressort de plus en plus du lot est l'Axe Parser.

A seulement 19 ans, Kevin Horowitz (alias Quigibo), étudiant en génie électrique et informatique, a eu l'idée de créer un langage qui allait mettre tout le monde d'accord. Le premier février 2010 sort une première version de l'Axe Parser. C'est un succès sur le forum omnimaga qui va en faire un de ses intérêts principaux.
Dès lors, les versions du compilateur se succèdent et se perfectionnent (encore aujourd'hui). Les possibilités de ce langage sont effarantes pour un résultat indiscutable.

Avantages et désavantages

Il n'y a pas de langage de programmation parfait. Chacun a ses 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é à faire beaucoup de choses, alors l'Axe Parser est fait pour vous.

Seulement, à chaque bon côté en Axe, il y a un mauvais côté (bon ok, il y a quand même plus de bons cotés :lol: ). Il arrive de temps en temps que votre code contienne une erreur où 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 (mais là, faut le chercher >_ ).

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.

Heureusement sur TI-83+ et TI-84+ vous disposez d'une mémoire flash vous permettant d'archiver vos programmes :

puis appuyez sur

pour archiver/désarchiver.

Il est également recommandé de bien sauvegarder vos codes sources sur un ordinateur en cas de problèmes. De plus, vous pouvez utiliser un émulateur (voir annexe).

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

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

Une annexe est prévue pour ça en fin de tutoriel : ici.

Maintenant il vous suffit d'aller dans le menu des applications avec la touche

, puis vous verrez Axe rajouté dans la liste. Démarrez-le, et vous devriez voir ça :

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

Un shell est un programme ou une application ayant une interface améliorée pour démarrer des programmes ASM prévus pour ce shell. Ici les programmes seront compilés à peu près comme pour l'ASM, donc on laisse le choix du type de shell.

Si vous préférez utiliser un shell, je vous conseille l'application noshell qui permet d'exécuter les programmes ASM qui ne nécessitent pas de shell, ainsi que certains nécessitant un shell (MirageOS et Ion notamment). Il s'installe via le menu de l'application et les programmes s'exécutent comme normalement dans le menu programme (archivé ou non).

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 prêt à être compilé.

• Le deuxième est une sauvegarde de source près à être restaurée (toujours précédé par le symbole dièse # devant lui).

Notion de compilation

On a vu plus haut que les programmes sur la TI peuvent être soit "interprétés", soit "compilés".

Seulement, pour que les actions comme "allumer un pixel à tel endroit" ou encore "stocker la valeur 4" soit réalisée, il faut que la calculatrice puisse lire un langage qui est propre à elle, le langage machine.

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.
Autres exemples de langages interprétés : le Javascript, le PHP, le Python, etc.

En revanche, un programme est compilé lorsque le code source est préalablement transformé 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 en général bien plus rapide ! ;)
Autres exemples de langages compilés : le C, le java, etc.

En Axe, c'est l'application Axe.8xk qui va transformer le code source en langage machine ; on l’appelle le compilateur.

Il faut savoir que lorsque vous compilez un code source contenant une erreur, une erreur de compilation apparaît.

Nous verrons l'utilité du contenu du reste du fichier zip plus tard (mais je ne vous interdis pas de le regarder ;) ).

Bon, je ne vous retiens pas plus, rendez-vous au prochain chapitre !

Créer le programme 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 (8 caractères maximums):

PROGRAM:AXESOURC
:.AXEEXEC

Ici j'ai créé le programme AXESOURC et lorsqu'il compilera il créera AXEEXEC.

Autre chose avant de commencer à programmer : quand vous allez compiler votre source non archivé et que vous avez une erreur de compilation, vous pouvez voir à quelle ligne se trouve précisément l'erreur en appuyant sur la touche

.

Afficher du texte

Commençons par ce qu'il y a de plus simple, écrire du texte.
Il existe 3 commandes pour afficher du texte en Axe, celles-ci sont très similaires au TI-Basic mais ne vous fiez pas aux apparences :
- La commande Text(

et la commande Text

:Text(X,Y,"MON TEXT
:.ou
:Text(X,Y
:Text "MON TEXT

La commande Text( affichera directement à un point (X,Y) le texte, alors que la commande Text nécessite qu'on ait préalablement mis un curseur pour savoir où placer le texte, cela peut être utile dans certains cas.

- La commande Disp

:Disp "MON TEXT

La commande Disp va afficher le texte en haut à gauche de l'écran. Quand le texte est trop long, il saute la ligne. Quand on enchaîne deux Disp dans un code, le deuxième s'affichera à la suite du premier.

- La commande Output(

:Output(X,Y,"MON TEXT

Ici on peut placer à un point donné notre texte.

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 une pause

Rah.. vous pouviez pas attendre que j'explique? :diable:

Donc, je disais qu'il fallait faire une pause pour nous laisser le temps de voir, seulement la commande Pause utilisée en TI-Basic n'a pas la même utilisation en Axe!
La commande Pause se trouve ici :

La pause en Axe est une durée pendant laquelle le programme va être arrêté. Cependant le nombre indiqué doit être au minimum de 1, donc les codes suivants ne sont pas bons :

:Pause

:Pause 0

Une seconde correspond environ à un Pause 1800. Donc deux secondes de pause reviendrait au code suivant :

:Pause 3600
:.Car 1800 fois 2 = 3600 = 2 seconde

Comme dans tout langage qui se respecte, l'Axe Parser possède une commande pour inclure des commentaires dans le source.
Pour commenter sur une seule ligne, on placera un point "." en début de ligne, sauf la première réservée au nom de l'exécutable.
On peut également faire des commentaires sur plusieurs lignes. Pour cela il faut commencer la première ligne par "..." et terminer la dernière de la même façon :

:...
:Ici un commentaire
:sur plusieurs lignes
:...

Ce qu'il faut retenir de ce chapitre, c'est surtout qu'il y a plusieurs commandes pour afficher du texte, et qu'il ne faut pas oublier qu'elles ont chacun des avantages qui fait qu'on les utilisera plus dans certaines situation que dans d'autres.
Rien de difficile encore, mais je vous préviens... le prochain chapitre relève un peu la barre. ;)

Les variables et quelques notions de mathématiques

Ahah je vous ai enfin piégés :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 !

Les opérations de base et les variables

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.

Pour définir une variable, rien de plus simple :

:0→A

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

Maintenant je veux donner 0 aux variable A et B :

: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 veux donner comme valeur 4 à A et 8 à B :

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

: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

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.

D'autres opérations

Maintenant on va voir quelques opérations plus complexes, et toujours utiles à savoir :

La valeur absolue :

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

Il faut savoir que c'est utile que pour les nombres compris entre -32768 et 32767, donc 65535 sera considéré comme -1 :

:abs(65535)→A
:.A=1
:abs(A-101)→A
:.A=100

Le maximum des deux expressions :

:12→A+6→B
:max(A,B)→C
:.Ici C=B car B=18

Le minimum des deux expressions :

:12→A+6→B
:min(A,B)→C
:.Ici C=A car C=12

Le carré de l'expression :

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

La racine de l'expression :

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

N'ignorez pas cette ligne car cela pourrait vous causer plein de problème par la suite. :-°

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 l'Axe Parser lit le calcul comme il vient, sans prendre compte des règles de priorités... SAUF les parenthèses quand il y en a.

Donc pour avoir le bon résultat de 1+1*2 en Axe on écrira 1+(1*2), mais le plus simple reste d'organiser son calcul comme cela : 1*2+1.

Calculs booléens

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 (prononcer "boule et un") :
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.

Les symboles tests

Un symbole test va en fait tester soit l'infériorité, soit la supériorité, soit l'infériorité/égale, soit la supériorité/égale, soit l'inégalité ou encore l'égalité de 2 expressions. Si le test de ces deux expressions est VRAI, il renverra 1. Si il est FAUX, il renverra 0. (tout compris ? :euh: )

Je suis sûr que vous comprendrez mieux avec ce code, en commençant avec le symbole égale :

:2→A+1→B
:.A vaut 2 et B vaut 3
:A=B→C
:.C vaut 0 car A n'est pas égal à B

Maintenant avec d'autres symboles :

• Strictement inférieur

  :2→A+8→B
  :.A vaut 2 et B vaut 10
  :A<B→C
  :.C est égal à 1 car A est plus petit que B

• Strictement supérieur

  :2→A+8→B
  :A>B→C
  :.C est égal à 0 car A n'est pas plus grand que B

• Inférieur ou égale

  :5→A→B
  :.A et B valent 5
  :4→D
  :.D vaut 4
  :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

  :5→A→B
  :4→D
  :A≥B→C
  :.C est égal à 1 car A est égal à B
  :D≥B→C
  :.C est égal à 0 car D n'est pas plus grand que B

Maintenant, petit test, trouvez quelle est la valeur de X dans ce code :

:2→A*4→B^3→C
:A<C→D≥0→X+B→X

Vous ne trouvez pas ? :-°
Voici la correction :
D'abord il faut comprendre quelles sont les valeurs que l'on a données à A, B et C :

:2→A*4→B^3→C
:.A vaut 2
:.B est égal à 2*4 soit 8
:.8 modulo 3 vaut 2, donc C vaut 2
:.(8 divisé par 3 a pour quotient 2 car il y a 2 fois 3 dans 8, mais il a pour reste 2 (8-(2*3)))

Ensuite on calcul avec attention :

:A<C→D≥0→X+B→X
:.A vaut B (=2), A n'est pas plus petit que 0 (c'est FAUX) donc D vaudra 0
:.D égal 0 (c'est VRAI) donc X est égal à 1
:.Seulement on rajoute la valeur de B à X (X+B) comme B vaut 8, 8 plus 1 est égal à 9, au final X vaudra 9.

Les opérateurs logiques

Un opérateur logique est un moyen de comparer plusieurs expressions testées, par exemple :

• 

  and compare si les deux expressions sont vraies : EXP1 and (EXP2).

  :0→A→B
  :(A>6) and (B=A)→C
  :(A≤0) and (B=A)→D

  EXP1 est égal à A>6 et EXP2 à B=A
  A>6 est FAUX (0 n'est pas plus grand que 6)
  B=A est vrai (0 est égal à 0)
  Les deux expressions ne sont pas vraies, C=0.
  A≤0 est vrai (0 est plus petit OU égale à 0)
  B=A est vrai (0 est égale à 0)
  Les deux expressions sont vraies donc D=1

  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 expressions on peut mieux visualiser le and dans la zone rouge.

• 

  or cherche à savoir si au moins une expression est vraie : EXP1 or EXP2

  :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 (à partir du moment où on remarque que l'une des expressions est vraie, on n'a même pas besoin de vérifier la deuxième car il en faut au moins une de VRAIE).
  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 :

  :0→A→B
  :(A>6) xor (B=A)→C
  :(A≤0) xor (B=A)→D

  C est égal à 1 car la deuxième expression est vraie (B=A) et la première est fausse.
  D est égal à 0 car ici les deux expressions sont vraies !
  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.

Ici, l'exercice va être d'afficher 0 quand A est égal à 1 (quand A est VRAI), et 1 quand A est égal à 0 (quand A est FAUX) avec un seul calcul qui aura le rôle d'inverseur. Vos deux résultats seront affichés une seconde chacun au centre de l'écran à peu près.

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 :

:Disp A►Dec

donc je récapitule :

:On initialise A à 0
:On fait le fameux calcul qui donnera la valeur 1 à A
:On affiche A vers le milieu de l'écran
:On attend une seconde
:On refait le fameux calcul qui cette fois donnera 0 à A
:On affiche A une ligne en dessous du premier résultat (toujours vers le centre de l'écran)
:On attend une seconde encore

Résultat

Maintenant que vous avez bien cherché et bien trouvé le résultat :-° , je vais vous montrer les possibilités qui s'offrent à vous :

Tout d'abord le principal code sans le calcul :

:0→A
:.Calcule→A 
:Output(6,3,A►Dec
:Pause 1800
:.Même calcul→A
:Output(6,3,A►Dec
:Pause 1800

La Pause 1800 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).

Pour le calcul, on pouvait soit faire avec un symbole :

:A<1→A
:...
:Quand A vaut 1, il n'est pas plus petit que 1, donc il vaut 0
:Quand A vaut 0, il est plus petit que 1 donc il vaut 1
:...
:A=0→A
:.Et c'est le même principe ici aussi
:A≠1→A
:.ainsi que là
:A≤0→A

On pouvait également faire par une astuce de calcul :

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

La solution retenue

La façon la plus optimisée de faire ce calcul est d'utiliser la commande xor. En effet on a vu que 0 xor 1 vaut un et 1 xor 1 vaut zéro :

:A xor 1→A

Donc voici le code final :

:0→A
:A xor 1→A 
:Output(8,4,A►Dec
:Pause 1800
:A xor 1→A
:Output(8,5,A►Dec
:Pause 1800

Relisez bien ce chapitre, c'est LE chapitre important pour cette première partie. Une fois que vous aurez compris l'intérêt des variables et des booléens, vous aurez compris beaucoup de choses. :ninja:

Explication de la condition

Une condition sert à tester une variable. Dans votre vie de tous les jours vous êtes confrontés à 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 donné deux euros à la boulangère, alors je n'ai pas de pain.

Cette deuxième condition va être une conséquence de la première et vice versa.

Donc dans un programme de jeu ça pourrait donner :

Si je meurs
Alors j'ai perdu la partie

Ici en Axe avec V qui est égal à 1 s'il reste une vie, ou V est égal à 0 s'il ne reste aucune vie :

:If V=0                 :.La condition commence ici ou on teste si V=0
:Disp "Game Over"       :.Si cette expression est VRAIE alors on affiche "Game Over"
:End                    :N'oubliez pas le End pour marquer la fin

Toute structure conditionnelle se termine par un End. Celui ci est présent pour signaler à notre programme que notre condition est terminée, 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.

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

Les structures conditionnelles classiques

On a vu précédemment les conditions les plus courtes :

:If (Ma Condition)
:.le code à exécuter
:End
:.toujours terminer par un End!

If...Else...End

Maintenant, si l'on veut exécuter un code quand la condition est vraie, et un autre quand elle est fausse, on utilisera Else de la façon suivante :

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

Oui ! C'est un programme !
Mais je vous rassure, on peut organiser ces conditions, grâce à une autre commande : ElseIf.

If...ElseIf...Else...End

Elseif sera utilisé comme ceci :

: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 reprends notre système de vie :

: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

En fait les conditions vérifient si les tests booléens sont vrais, donc en reprenant nos symboles tests :

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

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

Une autre particularité des booléens, on peut simplifier l'écriture suivante :

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

En celle ci :

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

Si, il existe les conditions inversées ! :-°

Les conditions inversées

En fait, les conditions inversées sont exactement pareilles que les conditions normales. On rajoutera juste le point d'exclamation ! :

:!If A
:.Si A est FAUX, on exécute ce code
:End

Il marchera donc pour toutes les variantes de la structure conditionnelle vue précédemment :

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

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

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

? ?? une autre structure !

Sachez qu'il existe une autre structure pour diminuer la taille de vos conditions dans votre code source. Tout d'abords regardons une condition simple comme on vient de le voir :

:If A<2
:6→A
:End

Ici, il y a deux choses intéressantes : A<2 et 6→A. On utilisera le point d'interrogation ? (

) pour réduire cette condition à :

:A<2?6→A

Maintenant si on veut l'équivalent avec la commande Else :

:If A<2
:6→A
:Else
:3→B
:End

On ajoutera une virgule après la première expression :

:A<2?6→A,3→B

Oui, et c'est tout aussi simple : il suffit de mettre deux points d'interrogation :

:A<2??3→B

De même avec le Else :

:A<2??3→B,6→A

Les conditions décrémentées

Ce type de condition est plus dur à comprendre car, en plus de tester une condition, elle va agir sur la variable testée en la décrémentant de 1 à chaque fois qu'elle est testée. Quand cette variable atteint 0, elle est restituée à sa valeur maximum que l'on aura définie.

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

Un exemple de condition décrémentée :

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

La première fois que la condition sera testée, X=3, comme X n'est pas égal à 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.

Cela tombe bien, c'est le sujet de notre prochain chapitre : Les boucles.

Normalement beaucoup de choses devraient s’éclaircir dans votre tête, mais je suis sûr qu'en lisant le chapitre suivant, vous aurez la tête... encore plus clair ! :ange:

La boucle Repeat

La boucle Repeat se traduit par : "répéter jusqu'à ce que telle condition soit vraie"

Syntaxe :

: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 veux répéter jusqu'à ce que le nombre de vies soit égal à 0 :

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

Non, pas trouvé ?
Bon OK je vous le donne :

:5→V
:Repeat V=0
:V-1→V
:End
:Disp "PERDU!"

Mieux encore, on peut mettre la ligne :V-1→V directement au début de la boucle :

:5→V
:Repeat V-1→V=0
:End
:Disp "PERDU!"

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 :

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

Contrairement au Repeat, le code s'exécutera tant que la condition sera vraie :

:While V
:.code à exécuter
:End
:Disp "PERDU!"

On reprend notre compteur de tout à l'heure, mais en simplifié bien sûr : :-°

:5→V
:While V-1→V
:.Tant que V est différent de 0
: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 :

:For(Variable,ValeurInitiale,ValeurDeFinDeBoucle)
:.code à exécuter
:End
:.Et bien sûr, le End.

Une variable choisie va être initialisée à la valeur initiale, et la boucle va être exécutée en incrémentant 1 à cette variable à chaque fois que le code est exécuté. 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( :

:For(A,0,7)
:Output(0,A,"Même texte
:End

Maintenant avec la variable derrière, cela pourrait donner :

:For(A,0,7)
:Output(0,A,"Choix")
:Output(6,A,A+1►Dec)
:End

EndIf et End!If

Voici une autre manière d'utiliser les boucles Repeat et While, en mettant la condition à la fin de la boucle. Pour cela il y a les commandes EndIf et End!If qui testent exactement de la même manière qu'une condition afin de quitter le programme ou non.

Par exemple, étudions le code suivant avec la boucle While :

:While 1
:.Code
:End!If V

While 1 sera toujours vrai car l'expression est égale à 1, donc la seule façon de quitter la boucle est de n'avoir plus aucun vie (ici la variable V).

Et on peux faire de même avec la boucle Repeat :

:Repeat 0
:.Code
:EndIf A>50

Repeat 0 est toujours faux car l'expression vaut zéro, cette fois il faudra attendre que A soit supérieur à 50 pour quitter la boucle.

En fait lorsque vous faites ce code :

:1→A
:Repeat A=1
:.Code A
:End
:.Fin

Seulement la partie surlignée (en jaune) sera exécutée, et le Code A sera ignoré. Or si vous mettez la condition à la fin :

:1→A
:Repeat 0
:.Code A
:EndIf A=1
:.Fin

Tout le code sera exécuté, même le Code A qui se trouve à l'intérieur de la boucle !

Cela est du au fait que la condition teste seulement à la fin de la boucle, donc le Code A est exécuté une fois avant que la boucle s'arrête. ;)

Maintenant on peux faire encore mieux, par exemple en combinant des conditions au début et à la fin :

:Repeat A<3 and (B<5
:.Code A
:End!If A

D'abord on teste si A est plus petit que 3 et qu'en même temps B est plus petit que 5. Si ce n'est pas le cas on exécute le Code A et à la fin de la boucle on test si A est égale à zéro. Si ce n'est pas le cas la boucle recommence, et ainsi de suite. :)

Arrivés ici, vous pensez avoir fait le tour des boucles. Pourtant, ce n'est pas fini ! Vous verrez que l'on peut faire encore plus avec les boucles : dans le prochain chapitre bien évidemment. :p

Explication

La commande getKey, comme en TI-Basic, repère si une touche à été pressée. On peut donc utiliser la même syntaxe qu'en TI-Basic :

:getKey→K

Donc la variable K va contenir la valeur d'une touche pressée.

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 tâche de double cliquer dessus pour voir l'image :ange: :

Non pas forcément, car si K est une simple valeur, on peut l'afficher sur la calculatrice, avec un programme !
Je vous laisse chercher comment faire :-° .

:-° Après quelques secondes vous aurez trouvé ce code :

:.GETKEY
:0→K
:Repeat K
:getKey→K
:End
:Text(0,0,K►Dec
:Pause 2000

Mais on peut l'optimiser en utilisant dès maintenant la commande getkey :

:.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ée, et s'éteindra quand la touche 15 aura été pressée :

Mieux encore, getKey→K peut être mis directement au début de la boucle !

:.GETKEY
:0→K
:Repeat getKey→K=15
:If K
:Text(0,0,K►Dec
:End
:End

:magicien:

Le getKey en action

En fait il y a 2 commandes getKey en Axe, la première va retourner un nombre pour une touche qui aurait été pressée (voir plus haut). Et la deuxième va retourner un booléen si une touche précise a été pressée.
Reprenons notre code pour les vies. Je veux que l'on quitte quand la touche

a été pressée :

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

L'avantage ? Grâce à cette commande, on peut repérer si plusieurs touches on été pressées en même temps !

:Repeat getKey(15)
:If getKey(9) or getKey(54)
:.code
:End
:If getKey(33) and getKey(25)
:.code
:End
:End

Mieux encore, on peut mettre le numéro de la touche dans une variable :

:15→X
:If getKey(X)
:End

En fait, il va repérer si une touche (n'importe laquelle) a été pressée, mais il est surtout utilisé pour savoir si aucune touche n'a été pressée :

:!If getKey(0)
:.Code à exécuter quand aucune touche n'a été pressée.
:End

Quoi ? vous pensiez que c'était plus compliqué que cela ? :lol: Que nenni !

Exercice

Énoncé

Pour vous échauffer pour le prochain chapitre, je vais donner un petit exercice sur la commande getKey.

Donc le but de l'exercice va ê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 pixels je le rappelle).
Le programme se ferme en appuyant sur

.

Astuce

Avant de vous lancer, je vais vous donner une commande pour incrémenter et décrémenter vos variables de 1. En gros, X+1→X et X-1→X deviennent respectivement :

:X++
:X--

J'en dis pas plus, à vos caltos ! :zorro:

Résultat

Vous êtes sûrs d'avoir bien cherché ? o_O

D'abord, il fallait choisir la commande pour afficher la lettre 'O'. La plus adaptée ici est la commande Text( car vue la rapidité du programme, 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 ; lorsque l'on déplace le 'O', celui-ci 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 efficace. 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 :

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

:If getKey(2) and (X≠0
:X--
:ElseIf getKey(3) and (X≠91
:X++
:End
:If getKey(4) and (Y≠0
:Y--
:ElseIf getKey(1) and (Y≠58
:Y++
:End

En tâtonnant vous aurez sûrement trouvé les valeurs 91 (pour la largeur) et 58 (pour la hauteur), qui correspondent à la place que prend la lettre 'O'.

Donc le code final :

: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--
:ElseIf getKey(3) and (X≠91
:X++
:End
:If getKey(4) and (Y≠0
:Y--
:ElseIf getKey(1) and (Y≠58
:Y++
:End
:End

Et voilà, vous avez terminé la première partie de ce cours.. ah non j'oubliais, un petit TP vous attend au prochain chapitre :D , relisez bien ce cours (comme d'habitude), vérifiez que vous avez du temps libre, et allez-y ! ;)

Quelques consignes

Menu principale

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

• Jouer ==> voir fonction de jeu.

• 

  Crédits ==> Crédits donne des informations sur le créateur, année de création et les personnes remerciées pour la création du jeu. Ces renseignements s'effaceront après avoir appuyé sur la touche

  .

• Quitter ==> Quitter quitte le jeu.

fonction de jeu

Le principe est le suivant : un chiffre entre 0 à 9 (choisi au hasard) tombe de l'écran (du haut vers le bas) et le joueur doit appuyer sur la touche correspondant à ce chiffre :

Lorsqu'un numéro a atteint le bas de l'écran, le joueur a perdu, et on peut le lui dire. ;)

Bien sûr n'importe quel joueur peut quitter à tout moment le jeu avec la touche :

La vitesse du jeu doit être croissante. A chaque numéro trouvé par le joueur, la vitesse doit augmenter.

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

• Faire un mode difficile (en faisant défiler plusieurs numéros 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éros à des endroits choisis au hasard.

• Et tout ce que vous imaginerez d'autre...

Les commandes à connaitre

J'allais vous le dire :ninja: .

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éatoire entre 0 et 65 535.

C'est là qu'intervient le super modulo :zorro: , cette tâche fait partie de ses spécialités :

:rand→A
:A^10→A

Et en simplifié :

:rand^10→A

En fait, le reste de la division euclidienne de n'importe quel entier par 10, sera toujours compris entre 0 et 9 (car 10 est divisible par 10), de même si je veux créer un nombre aléatoire entre 0 et 95 :

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

Correction

Après avoir amélioré votre programme mieux que je ne saurais le faire, vous venez ici pour voir ma modeste correction ? :p

Le menu et le crédit

Soit, commençons par le commencement : il vous faut un menu qui réagisse en fonction des touches choisies.
Ici j'ai choisi la touche

pour jouer,

pour le crédit et

pour quitter :

:.PLUIENUM
:.Le menu principal
: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.

Ensuite je fais mon crédit, qui revient au menu après avoir appuyé sur la touche

:

: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 vue plus haut. Et j'attends que la touche

soit pressée avec une boucle avec rien dedans.

Le jeu

Passons aux choses sérieuses.

D'abord, comment choisir un nombre aléatoire :

:!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ée correspond au nombre N, on peut faire :

: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 la touche appuyée 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 :

: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 qu'une valeur à chaque fois, il n'y a pas de risque que I soit égal à 2 ou plus.

Et encore amélioré :magicien: :

N=0 and getKey(33) or (N=1 and getKey(34)) or (N=2 and getKey(26)) or (N=3 and getKey(18)) or (N=4 and getKey(35)) or (N=5 and getKey(27)) or (N=6 and getKey(19)) or (N=7 and getKey(36)) or (N=8 and getKey(28)) or (N=9 and getKey(20))→I+S→S

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 anti-triche en remplaçant les or par des xor :

:N=0 and getKey(33) xor (N=1 and getKey(34)) xor (N=2 and getKey(26)) xor (N=3 and getKey(18)) xor (N=4 and getKey(35)) xor (N=5 and getKey(27)) xor (N=6 and getKey(19)) xor (N=7 and getKey(36)) xor (N=8 and getKey(28)) xor (N=9 and getKey(20))→I+S→S

Le ou exclusif (xor) va obliger qu'une seule touche soit pressée. 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 :

:Text(40,B,N►Dec
:Pause W
: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 et le numéro déjà à l'écran doit s'effacer :

:Text(40,B,N►Dec
:If I
:W>1?W--
:ClrHome
:0→I→T→B
:.T=0, on recréé un nombre aléatoire
:.B=0, N est affiché en haut de l'écran
:End
:Pause W
:B++

Toute la partie de jeu :

:.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 fonction de B
:Text(40,B,N►Dec
:.On vérifie si la touche pressée correspond à N (avec un code anti-triche)
:N=0 and getKey(33) xor (N=1 and getKey(34)) xor (N=2 and getKey(26)) xor (N=3 and getKey(18)) xor (N=4 and getKey(35)) xor (N=5 and getKey(27)) xor (N=6 and getKey(19)) xor (N=7 and getKey(36)) xor (N=8 and getKey(28)) xor (N=9 and getKey(20))→I+S→S
:.Si cela correspond, on initialise les variables et le temps W diminue
:If I
:W>1?W--
:ClrHome
:0→I→T→B
:End
:
:Pause W
:B++
:End
:.On efface l'écran
:ClrHome
:.Le score s'affiche dans le menu principal
: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 montrerai 3 améliorations 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 choisie 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:
Ce n'est qu'un exemple, et vous êtes libre de faire l'intro que vous voulez :

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

• Faire apparaître les numéros à des endroits choisis 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 :

:!If T
:rand^10→N
:rand^92→A
:1→T
:End

• Faire un mode difficile (en faisant défiler plusieurs numéros 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éros). :soleil:
Le but va être de rajouter un deuxième numéro, sans que cela ne perturbe le premier code. On va donc être obligé de recopier le même code mais avec des noms de variables différents. Il faudra que ce code soit pris en compte seulement lorsque le joueur l'a choisi (via un menu) :

:ClrHome
:Repeat getKey(9)
:Text(0,10,"Niveau :
:Text(28,10,L►Dec
:L<1 and getKey(4)-(L>0 and getKey(1))+L->L
:End

Bien sûr 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 :

:Repeat Y=60 or (B=60) or getKey(15)
:.Code
:If L
:!If U
:rand^10→M
:rand^92→X
:1→U
:End
:End
:.Code
: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 raccourcit 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
:.Code
:If J
:W>1?W--
:End
:ClrHome
:0→J→U→Y
:End
:.Code
:L?Y++

Le code final :

:.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 principal
: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
:L<1 and getKey(4)-(L>0 and getKey(1))+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
:L?Text(X,Y,M►Dec
:If N=0 and getKey(33) xor (N=1 and getKey(34)) xor (N=2 and getKey(26)) xor (N=3 and getKey(18)) xor (N=4 and getKey(35)) xor (N=5 and getKey(27)) xor (N=6 and getKey(19)) xor (N=7 and getKey(36)) xor (N=8 and getKey(28)) xor (N=9 and getKey(20))→I+S→S
:If L
:M=0 and getKey(33) xor (M=1 and getKey(34)) xor (M=2 and getKey(26)) xor (M=3 and getKey(18)) xor (M=4 and getKey(35)) xor (M=5 and getKey(27)) xor (M=6 and getKey(19)) xor (M=7 and getKey(36)) xor (M=8 and getKey(28)) xor (M=9 and getKey(20))→J+S→S
:End
:End
:If I
:W>1?W--
:ClrHome
:0→I→T→B
:End
:If J
:W>1?W--
:ClrHome
:0→J→U→Y
:End
:Pause W
:B++
:L?Y++
: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 Cree 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 reparlerai pas de ce TP dans les chapitres suivants, néanmoins vous allez apprendre de nouvelles choses dans la prochaine partie (des tas de nouvelles choses :waw: ) qui pourront être utilisées dans ce programme pour l'optimiser encore plus, le rendre encore plus beau, plus rapide, plus jouable... (plus parfait ?).
Je vous mets 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. Avant d'aller lire la deuxième partie, 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 ==> [].

La théorie

Vous devez comprendre ce qu'est un pointeur ! Si vous n'avez jamais utilisé de langage de programmation utilisant les pointeurs avant, soyez très attentifs. Les pointeurs sont des outils puissants et utiles que vous allez utiliser dans pratiquement tous vos programmes. Ils permettent d'organiser la RAM.

Littéralement Random-access memory : mémoire à accès aléatoire.
C'est de la mémoire vive alimentée constamment par vos piles qui est constituée environ de :

• 32 768 octets pour les TI-83+.

• 131 072 octets pour les TI-83+SE.

• 131 072 octets pour les TI-84+ ; pour les révisions matériels A à G sans lettre.

• 49 152 octets pour les TI-84+ ; pour les révisions matériels H et plus.

• 131 072 octets pour les TI-84+SE ; pour les révisions matériels A à G sans lettre.

• 49 152 octets pour les TI-84+SE ; pour les révisions matériels H et plus.

• 131 072 octets pour les TI-Nspire non-CAS en mode 84+SE.

Sur tous les modèles vous ne verrez que 24Ko d'affiché dans le menu mémoire (

), c'est en fait la mémoire allouée pour stocker vos programmes et autres données. ;)

Un octet est constitué de 8 bits. Un bit est une partie modifiable de la mémoire dans lequel on peut stocker une valeur égale à 0 ou 1. Donc un octet est égale à 8 bits de valeur 0 ou 1.
Voici quelques exemples de combinaisons d’octets :
00000000
00000001
00000011
00000110
10010101
00101100
00000111
00001000
01010000
Il y a beaucoup de combinaisons possibles, mais je n'en dis pas plus pour l'instant. ;)

Par le moyen le plus simple : donner à chaque octet de RAM sa propre adresse.
L'octet 0 a l'adresse 0, l'octet 1 a l'adresse 1, et ce jusqu'au dernier octet 32 767 de l'adresse 32 767 (pour une TI-83+).

Donc lorsque vous démarrez votre programme, celui ci doit être mis dans la RAM.
C'est là qu'intervient le pointeur, celui ci va également être dans la RAM, mais sa valeur va être l'adresse d'un endroit dans le programme (dans la RAM également).

La pratique

Voici un exemple de pointeur sur une chaîne de caractères :

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

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 chaîne réelle.
Donc, la phrase "Hello World" est stockée dans l'exécutable à une certaine 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. Ce nombre va indiquer une adresse, et c'est comme cela qu'il sait où trouver la chaîne de caractère à afficher.

Seulement, la chaîne de caractère "Hello world" ne peut pas tenir en un seul octet, il faut donc répartir chaque caractère dans un octet. Plus précisément, il y a une lettre par octet.

Imaginons que la lettre H soit dans l'octet 1200, Str1 va donc contenir le nombre 1200, et quand on fait appel à lui il va lire la chaîne en lisant les octets aux adresses qui suivent 1200 :

En fait, ce 0 est mis automatiquement à chaque fois qu'une chaîne de caractère est pointée. Son rôle n'est pas négligeable : il permet d'arrêter la lecture des octets. Imaginez, sans lui votre Disp afficherait toute la mémoire vive de votre calculatrice sous forme de caractères. :waw:

En Axe, Str1 est ce que l'on appelle un pointeur statique. Cela signifie qu'une fois qu'il est déclaré, sa valeur ne peut pas changer par la suite dans le programme.

Les pointeurs statiques sont Str, Pic, et GDB. Vous pouvez les utiliser comme vous voulez. Ce sont de simples 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 ne sont les variables utilisées en TI-Basic.

:ange: Pas maintenant, cela fera l'objet d'un prochain chapitre !

Évolution possible

Oui on peut faire des maths avec un pointeur ! Observons ce code par exemple :

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

Cela affichera juste "World", car la chaîne est stockée dans l'ordre dans des adresses. Reprenons nos adresses de tout à l'heure, 1200+6= 1206 :

Donc, au moment où nous arrivons à l'adresse 1206, nous sommes à "W". C'est pourquoi l'affichage de la partie "Hello " sera sautée.

Un petit exercice de recherche qui va vous aider à comprendre tout ça : lorsque je démarre mon jeu, je veux faire apparaître un "chargement" avec les petits points derrière qui défilent : d'abord aucun, puis le premier apparaît, le deuxième, le troisième, enfin on efface les 3 d'un coup pour n'avoir que le texte "chargement". On peut bien entendu répéter cela plusieurs fois, voire même jusqu'à ce qu'une touche soit pressée.

Dans une une boucle For( on mettra une condition décrémentée :

:.LOAD
:
:"CHARGEMENT"→Str0LOAD                      :.Initialisation des chaînes de caractères
:"...."→Str4PTS
:4→Y                                        :.Initialisation de Y
:
:For(Z,0,10)                                :.Cette boucle For va se répéter 11 fois
:DS<(Y,4)                                   :.Quand Y vaut 0, le code suivant est exécuté, mais Y est ensuite initialisé à 4
:ClrHome                                    :.Quand Y est égale à 0, on efface l'écran pour empêcher d'afficher toujours 3 points
:End
:
:Output(0,0,Str0LOAD                        :.On affiche le chargement
:Output(10,0,Str4PTS+Y                      :.avec le nombre de points voulu
:
:Pause 600                                  :.Sans pause le programme irait trop vite et l'on ne verrait rien
:End

Je ne vous laisserai pas passer si vous n'avez pas compris. :colere2:
Sans ces pointeurs vos programmes seraient beaucoup moins marrants à lire, c'est un outil indispensable pour la suite du cours.

Les labels

Maintenant que vous savez ce qu'est un pointeur, il vous sera plus facile de comprendre ce qu'est un label (littéralement une étiquette). C'est en fait un repère placé dans votre programme, auquel on peut faire appel lorsque l'on en a besoin.

Dans un programme en Axe, on utilisera la commande Lbl suivi du nom du label. Ce nom est composé de 5 caractères (lettre majuscule et minuscule et chiffres) maximum :

:.code A
:Lbl Label
:.code B
:Lbl Test1
:.etc

Par les adresses pardi ! :D
Il suffit d'indiquer l'adresse où l'on veut aller (l'adresse est notre repère) et en un rien de temps notre programme bascule vers le code qui commence à partir de cette adresse.

Heureusement les commandes pour faire cela sont très simples à utiliser, et le compilateur va remplacer tout seul les noms des labels par leur adresse correspondante. :)

La première façon de l'utiliser avec la commande Goto, celle-ci permet d'aller au label par un aller simple :

:Goto HEY
:.code A
:Lbl HEY
:.code B

Le code A sera donc sauté, et l'on passera au code B directement.
Le problème c'est que l'on est vite rempli de Goto :

:Lbl 0
:Goto HEY
:Lbl CO
:Goto F
:Lbl HEY
:Goto CO
:Lbl F
:Goto 0

Donc ils peuvent être utiles, mais il ne faut pas en abuser !
Les goto peuvent donner de mauvaises habitudes de programmation, si vous les utilisez trop, vous risquerez de faire du code rempli de label et de goto, au détriment des boucles, ce qui rendra votre code illisible et très mal optimisé ! :colere2:

Appeler une fonction

Pour éviter de remplir vos codes de Goto, il existe une autre commande très pratique, qui fait appelle à vos label comme des fonctions !

Une fonction va être une partie de code qui va faire une action bien précise, par exemple, si dans mon code principal je dois afficher à plusieurs endroits le même code, je peux créer une fonction pour appeler ce code à ma guise (oui, à ma guise :lol: ).

Le code d'une fonction est encadré par 2 commandes, la première est le Lbl déjà vu, et la deuxième est un Return, que l'on trouve ici :

Donc on aura ce code pour une fonction :

:Lbl Fnct
:.Code de la fonction
:Return

Il existe deux manière d'appeler une fonction, soit avec la commande sub( suivi du label, soit en marquant directement le label mais en rajoutant des parenthèses :

:Code A
:sub(Fnct)
:Fnct()
:.Code C
:
:Lbl Fnct
:.Code B
:Return

Dans l'ordre on exécutera le code A, le code B deux fois, puis le code C et une troisième fois le code B.

En fait, le programme précédent s'arrêtera au Return de la dernière ligne, car celle ci ne sert pas qu'à terminer les fonctions, elle ferme le programme si aucune fonction n'est en cours. Pour éviter de passer toujours par les fonctions avant de quitter le programme, on mettra le Return après le code C :

:Code A
:sub(Fnct)
:Fnct()
:.Code C
:Return
:
:Lbl Fnct
:.Code B
:Return

Le Return va également renvoyer la dernière valeur modifiée ou lue dans la fonction. Par exemple :

:Fnct()→B
:.On récupère la valeur de retour, B vaut donc 1
:
:Lbl Fnct
:.Code
:1
:Return

Mais aussi de cette manière en l'indiquant directement derrière le Return :

:Fnct()→B
:.B vaut donc 5
:
:Lbl Fnct
:.Code
:Return 5

Il existe également deux instructions de retour conditionnel : ReturnIf EXP pour simplifier le code suivant :

:If EXP
:Return
:End

En celui-ci :

:ReturnIf EXP

Bien sûr il existe le complément Return!If EXP qui s'utilise de la même manière :

:Return!If EXP

Autre chose à savoir : la fin d'un programme est elle-même un Return !
Donc exceptionnellement, pour les fonctions situées en fin de programme, on peut s'abstenir de Return.

On peut donc organiser notre code avec les fonctions, à peu près comme sur ce schéma :

:.MONPROGR
:
:sub(ZZZ)
:
:sub(A1)
:
:sub(ZZZ)
:
:Return
:
:Lbl A
:.Code A
:Return
:
:Lbl A1
:.Code B
:Return
:
:.Vous mettez toutes les fonctions dont vous avez besoin
:
:Lbl ZZZ
:sub(A)
:.Code Z
:.La fin du programme est un Return

Et oui, comme une fonction n'est que du code, on peut y appeler d'autres fonctions !

Les variables temporaires

Parfois, vous faites plusieurs fois les mêmes calculs mais avec des variables différentes, par exemple :

:A*2+8/255→A
:B*2+8/255→B
:.Ou encore
:Text(cos(X+3),sin(Y-3),"A
:Text(cos(A+3),sin(B-3),"A
:

Pour vous simplifier la vie on a créé des variables dites temporaires ; mais en réalité ce sont de simples variables : r1, r2, r3, r4, r5 et r6.

De ce fait, on peut faire tout ce que l'on fait avec les autres variables avec :

:r1*2+8/255
:Text(cos(r1+3),sin(r2-3),"A

Mais leur particularité est que l'on peut les utiliser facilement dans les fonctions en tant qu'arguments. Pour cela il faut rajouter les valeurs à envoyer après le label, en ajoutant une virgule :

:sub(FX,A,B,C)
:.Ou encore
:FX(A,B,C)
:.On peut mettre jusqu'à 6 arguments
:Return
:
:Lbl FX
:.r1 vaut A, r2 vaut B, r3 vaut C

En reprenant les exemples plus haut :

:Calc1(A)→A
:Calc1(B)→B
:
:sub(TEXT,X,Y)
:sub(TEXT,A,B)
:Return
:
:Lbl Calc1
:r1*2+8/255
:Return
:
:Lbl TEXT
:Text(cos(r1+3),sin(r2-3),"A

Faux, en apparence votre code paraît plus important, mais en réalité il est simplifié. Je suis sûr que vous vous rendrez compte très rapidement de l'importance des fonctions quand celles ci feront plusieurs lignes. :diable:

Exercice d'application

Pour vous entraîner, voici un code à simplifier à l'aide de tous les outils que vous avez vus jusqu'à présent :

:.SRC
:rand^500*14-13→A
:rand^500*14-13→B
:rand^500*14-13→C
:rand^500*14-13→D
:rand^500*14-13→E
:Disp "HEY WORLD
:Repeat getKey(9)
:End
:While getKey(9)
:End
:ClrHome
:rand^10→W
:rand^11→X
:rand^12→Y
:rand^13→Z
:Output(0,0,W►Dec
:Output(0,1,X►Dec
:Output(0,2,Y►Dec
:Output(0,3,Z►Dec
:Repeat getKey(9)
:End
:While getKey(9)
:End

Vous aurez peut être trouvé d'autres simplifications que celle ci, mais j'ai préféré supprimer les variables W, X, Y et Z :

:.Src
:Rand1()→A
:Rand1()→B
:Rand1()→C
:Rand1()→D
:Rand1()→E
:Disp "HEY WORLD
:Pause()
:ClrHome
:For(Z,10,13)
:Output(0,Z-10,rand^Z►Dec
:End
:Pause()
:Return
:
:Lbl Pause
:Repeat getKey(9)
:End
:While getKey(9)
:End
:Return
:
:Rand1
:Return rand^500*14-13

Ce code paraît plus long, mais il réduit presque de moitié la taille de votre programme !

Ce chapitre est peut être le plus facile à comprendre pour cette partie, relisez le bien, mettez des fonctions partout où vous le pouvez et entraînez vous bien !

Plusieurs écrans en un seul

Vous voyez 96 pixels par 64 pixels, et vous croyez avoir fait le tour de votre écran ? :-°
Techniquement oui, cependant, il existe plusieurs écrans temporaires prêts à être affichés à tout moment.

Le fonctionnement

Tout d'abord le vrai écran existe (si si croyez moi :p ), c'est celui que vous voyez, il est composé de 96*64 (=6144) pixels : à chaque pixel on donne un statut : 1=allumé, 0=éteint.

Ensuite il y a l'écran temporaire, c'est une mémoire dans votre calculatrice spécifiée pour enregistrer le statut d'un écran, que l'on peut afficher sur le vrai écran quand on veut. Pour une meilleur compréhension, on appellera cet écran le buffer (du mot anglais qui veut dire écran tampon).

Le problème du vrai écran, c'est qu'il affiche les pixels en temps réel. Ce n'est donc pas très pratique de changer de décor si l'on doit observer tous les pixels changer un par un, cela enlève tout suspens (c'est plus simple à dire comme ça). :p
Grâce au buffer, on va pouvoir dessiner entièrement l'image voulue, puis l'afficher.

Par exemple, à gauche le buffer et à droite l'écran :

le vrai écran affiche "bonjour"

Pour l'instant je n'ai rien dans le buffer

Maintenant, j'affiche "tout le monde" dans le buffer :

le vrai écran affiche toujours "bonjour"

J'affiche "tout le monde" dans le buffer

Puis j'affiche le buffer à l'écran :

le vrai écran affiche "tous le monde"

"tout le monde" est toujours dans le buffer

Afficher et effacer les différents écrans

Pour effacer le vrai écran, on connait déjà la commande : ClrHome.
Maintenant, si on veut afficher le buffer sur le vrai écran, il y a la commande DispGraph :

.
Puis, si on veut afficher le vrai écran sur le buffer on utilisera la commande StoreGDB qui se trouve ici :

.
Enfin, pour effacer le buffer, on peut utiliser la commande ClrDraw qui se trouve ici :

.
On peut également simplifier le code :

:DispGraph
:ClrDraw

On obtient le code suivant :

:DispGraphClrDraw

Ce dernier est environ deux fois plus rapide que le précédent.

Pour donner un simple exemple d'utilisation, un programme qui sauve l'écran temporairement :

:Text(20,20,"PLOP"
:.PLOP apparaît sur le vrai écran
:StoreGDB 
:.PLOP apparaît également sur le buffer
:ClrHome
:.On efface le vrai écran
:Repeat getKey(0)
:.L'écran reste blanc tant qu'on appuie pas sur une touche
:End
:DispGraphClrDraw
:...
:On affiche le buffer sur le vrai écran, on retrouve donc notre PLOP
:Puis on efface le buffer, mais PLOP est toujours sur le vrai écran
:...
:Pause 2000

Pixels et Géométrie

Pour dessiner sur cet écran intermédiaire, on aura ici une palette d'outils géométriques qui sont :

• Afficher un pixel.

• Afficher un cercle.

• Afficher un rectangle.

• Afficher un rectangle inversé.

• Inverser tous les pixels.

Afficher un pixel

Pour afficher un pixel, on utilisera la commande Pxl-On( :

:30→X→Y
:Pxl-On(X,Y)
:DispGraph
:Pause 1800

Les axes X et Y sont évidemment compris en 0 et 95 pour X et 0 et 63 pour Y.

On peut également effacer un pixel avec la commande Pxl-Off( :

:30→X→Y
:Pxl-Off(X,Y)
:DispGraph
:Pause 1800

Dans le même principe, on peut inverser un pixel avec la commande Pxl-Change( :

Afficher un cercle

Pour afficher un cercle on utilise la commande Circle( (

). Le centre du cercle a pour centre les coordonnés X et Y et a pour rayon R en pixels.

:30→X→Y
:5→R
:Circle(X,Y,R)
:60→X
:10→R
:Circle(X,Y,R)
:DispGraph
:Pause 1800

Afficher un rectangle

La commande utilisée pour le rectangle normal est Rect( (

). Les coordonnées X et Y se situent en haut à gauche du rectangle, W est la largeur (comme width en anglais) et H est la hauteur (comme height en anglais) :

:30→X→Y→W→H
:Rect(X,Y,W,H)
:DispGraph
:Pause 1800

Afficher un rectangle inversant

La commande utilisée pour le rectangle inversant est RectI( (

). Les coordonnées X et Y se situent en haut à gauche du rectangle, W est la largeur (comme width en anglais) et H est la hauteur (comme height en anglais) :

:30→X→Y→W→H
:Rect(X,Y,W,H)
:W/2+X→X→Y
:RectI(X,Y,W,H)
:DispGraph
:Pause 1800

Inverser l'écran

C'est très facile, il faut utiliser la commande DrawInv :

:DrawInv 
:DispGraph

Le troisième écran

Promis, c'est le dernier ! :-°

Celui ci s'appelle le back-buffer, il ne peut pas être affiché directement sur le vrai écran ! Il peut être affiché entièrement seulement en passant par le buffer.

Il peut avoir de nombreuses utilisations dans un programme, mais sa principale utilité fera l'objet d'un prochain chapitre sur les niveaux de gris. :ange:

En attendant on peut toujours apprendre à le manipuler.

Modifier et exporter le back-buffer

Pour copier le back-buffer sur le buffer, on utilisera la commande RecallPic :

.

Pour effacer le back-buffer, on utilisera la commande ClrDrawʳ, composé de ClrDraw déjà vu (

) et du ʳ :

Et pour copier le buffer dans le back-buffer, on utilisera la commande StorePic :

Bien évidemment, il suffit de reprendre toutes les commandes vues précédemment et d'y rajouter le petit ʳ :
Pxl-On(X,Y)ʳ
Pxl-Off(X,Y)ʳ
Pxl-Change(X,Y)ʳ
Line(X1,Y1,X2,Y2)ʳ
Circle(X,Y,R)ʳ
Rect(X,Y,W,H)ʳ
RectI(X,Y,W,H)ʳ
DrawInv ʳ

En conclusion, chaque écran a ses avantages et ses défauts, mais je suis sûr que vous saurez rapidement comment les exploiter au maximum. :)
Je tiens à remercier mdr1 pour certaines précisions qu'il m'a apporté sur ce chapitre. ;)
Aller, chapitre suivant !

Le binaire

Pour pouvoir comprendre la suite du cours, vous devez connaître quelques notions : le binaire et l’hexadécimal.

Et alors ? un petit rappel ne fera pas de mal. :p

Apprenons à compter

Tout d'abord il faut savoir ce qu'est une base numérique. La base la plus répandue aujourd'hui est la base 10 ; l'évolution a fait que l'homme a eu 10 doigts et qu'il a appris à compter avec ses 10 doigts. Donc, cette base 10 (appelée aussi base décimale), est constituée de 10 numéros :

0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

Une fois que nous atteignons le dernier numéro, nous créons un nouvel emplacement en face du premier, et en incrémentant de 1 à chaque fois que l'emplacement précédent arrive à plus de 9 (il faut donc créer une dizaine) :

8, 9, 10, 11, 12, ..., 19, 20, ...

Et ainsi de suite pour les centaines, les milliers, etc.

Si l'on étudie notre façon de compter, on se rend compte que chaque emplacement ajouté est une puissance de 10 en plus :

En fait, lorsque l'on change de base, ce tableau restera le même : on changera juste le nombre 10 par celui de la base voulue.

Le binaire

Le binaire (ou base 2) n'est constitué que de 2 numéros : 0 et 1. On y compte comme dans toutes les bases, en rajoutant un emplacement une fois que le précédent atteint le maximum de la base :
0, 1, 10, 11, 100, 101, etc.

Un petit tableau s'impose pour comparer le binaire et le décimal :

Ici, je laisse les 0 en trop pour une meilleure vue d'ensemble.

Si, pour cela reprenons le tableau précédent adapté à la base 2 :

Pour le nombre 101010 :

Il suffit de connaître votre table de 2 et le tour est joué ! :soleil:

Quoi ? Vous ne la connaissez pas ? Je suis sûr que vous trouverez votre bonheur ici.

C'est encore plus simple, la méthode consiste à décomposer le nombre décimal en plusieurs puissances de 2. Je prends le nombre 87 par exemple ; la puissance de 2 inférieure à 87 la plus proche est 64 :

87-64=23

On commence donc le nombre binaire par 1. Ensuite si on essaye avec le multiple en dessous :

23-32

Cela n'est pas possible car 32 est supérieur à 23, notre nombre binaire est de 10. Essayons avec la puissance en dessous :

23-16=7

Notre nombre binaire est de 101.

7-8

Pas possible, 8 est plus grand que 7. Donc en binaire on a 1010.

7-4=3

En binaire 10101.

3-2=1

En binaire 101011.

1-1=0

En binaire 1010111.

Maintenant, quelques conversions pour vous entraîner, remplissez le tableau ci dessous :

La correction :
Pour l'expression 1, on a 4 chiffres binaires. On met tout ça dans notre tableau :

Dans l'expression 2, on a 8 chiffres binaires. Pareil qu'au dessus :

Dans l’expression 3, vous pouviez faire de nouveau un tableau, mais il y a d'autres méthodes plus simples. On calcule facilement que 10000 en binaire est égale à 16 en décimal (2^4). Donc 16-1=15, on peut donc dire que 1111=15.

Si vous aviez trouvé l'expression 3, vous n'avez sûrement rien eu à calculer pour l'expression 4, car on a vu que 1111=15.

L'expression 5 est également très facile à trouver, 128 étant une puissance de 2, il fallait juste ne pas se tromper sur le nombre de zéro à rajouter :
128=10000000

Vous retrouverez d'autres façons de faire sur ce site (pour votre culture personnelle :) ).

L’hexadécimal

Je ne ferai pas complètement le tour du sujet, mais seulement la partie qui nous intéresse autour de l'hexadécimal.

L’hexadécimal par rapport au décimal

L'hexadécimal est en fait la base 16. Seulement, il manque des chiffres pour arriver jusqu'à 16. On a donc utilisé des lettres, en l’occurrence ici les 6 premières lettres de l'alphabet :
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F,...

Puis on passe à l'emplacement suivant (comme dans toutes les bases) :
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 1C, 1D, 1E, 1F, 20,..., A0,..., 100,..., A00, etc.

En décimal, ils valent respectivement : 10, 11, 12, 13, 14 et 15.
Un tableau s'impose :

Et quand on arrive à F, on passe à 10 :

Et ainsi de suite !

Je ne vais pas m'attarder plus sur la conversion de l'hexadécimal en décimal, je vous conseillerai juste de convertir l'hexadécimal en binaire, puis en décimal.

L’hexadécimal par rapport au binaire

La conversion de l'hexadécimal en binaire (et vice versa) est très simple ! Il vous suffit de connaître la tableau suivant :

Vous devez connaître ce tableau ; prenez quelques minutes, heures s'il le faut pour apprendre ce tableau par cœur.

C'est là qu'il faut observer quelque chose d'important sur le tableau : lorsque l'on arrive à F en hexadécimal on arrive à 1111 en binaire. Il y a une relation qui fait qu'à ce moment les deux bases vont augmenter d'un emplacement. Je suis sûr que vous avez deviné la relation entre ces deux bases, non ? :euh:

Je vous aide un peu :
Parce que 16 est une puissance de 2 !

On peut en conclure que 1 chiffre hexadécimal est égal à 4 chiffres binaires !
Donc, si vous connaissez le tableau plus haut par cœur, vous arriverez à convertir le nombre 1BF5A0 très rapidement :
0001 1011 1111 0101 1010 0000
Ou plus clairement :
1BF5A0000110111111010110100000

(Soit 1832352 en décimal)

De même, pour trouver la valeur hexadécimal de 010111011011101000110010 :
0101110110111010001100105DBA32

(Soit 6142514 en décimal)

En fait, pour comprendre la suite du cours, vous aurez besoin de convertir le binaire en hexadécimal (très souvent), et l’hexadécimal en décimal (peu souvent).

Une histoire d'octets

Revenons à nos octets, et particulièrement à la question "qu'est ce qu'un octet ?".
Un octet est composé de 8 bits. Un bit a deux valeurs possibles : 0 ou 1. (une impression de déjà vu ? :D )

Maintenant on assimile cela aux connaissances vues précédemment ; un bit est un chiffre binaire ; un octet est un nombre binaire de 8 chiffres maximum.

Petit exercice maintenant : déterminez la valeur maximale d'un octet en décimal.

Un indice :
11111111 en Binaire.

Réponse :
255 en décimal.

Ce nombre vous évoque des choses ?
Maintenant, calculez la valeur maximale de deux octets :

Un indice :
11111111 11111111 en Binaire.

Réponse :
65535 en décimal.

C'est maintenant que vous vous rappelez ; cette valeur est celle que l'on obtient quand on fait 0-1→A.
Cela signifie que votre variable est en fait composé de 2 octets.

Rappelez vous, 1 chiffre hexadécimal vaut 4 chiffres binaires. On pourra donc écrire un octet sous forme de 2 caractères hexadécimaux. :)

En gros chaque lettre correspond à un nombre, et lors de l'affichage, la calculatrice va convertir ce nombre en lettre. Mais patience, cela fera l'objet d'un prochain chapitre. :ange:

Les Datas : de simples données

Maintenant que vous connaissez vos octets sur le bout des doigts, vous allez pouvoir étudier ce qu'il retourne des Datas. :-°

Une liste de données

La commande Data( va créer une liste de valeurs que l'on utilisera pendant le programme. Chaque valeur sera en fait stockée dans un octet, et vous l'aurez deviné, on assimilera tout cela avec des pointeurs :

:Data(42,12,13,7)→GDB1

Quand on fait cela, le pointeur statique GDB1 va pointer l'octet contenant la valeur 42, et comme pour les chaînes de caractères, le reste des valeurs se place à la suite de cet octet.

Pour manipuler un seul octet à partir d'une adresse, il faut utiliser les accolades :

:{GDB1}

En fait, {GDB1} se manipule comme une variable d'un octet, sa valeur est toujours comprise entre 0 et 255.

En effet, si vous ne pouvez pas changer la valeur d'un pointeur statique, vous pouvez changer la valeur de l'octet pointé :

:Data(42,12,13,7)→GDB1
:Disp {GDB1}►Dec
:.Affiche 42
:1→{GDB1}
:Disp {GDB1}►Dec
:.Affiche 1

Et amusons nous à passer d'un octet à un autre :D :

:Data(42,12,13,7)→GDB1
:Disp {GDB1+2}►Dec
:.Affiche 13
:{GDB1}+{GDB1+1}→A
:.42+12=54
:Disp A►Dec
:.Affiche 54

Ce tableau devrait vous rappeler quelque chose :

Transformer de l'hexadécimal en Data

Maintenant, nous allons transformer des chiffres hexadécimaux en Data. Cela n'a rien de compliqué ; c'est même fait pour. ;)

Toute data hexadécimale doit se mettre entre crochets :

:[2A0C0D07]→GDB1
:For(Z,0,3)
:Disp {GDB1+Z}►Dec
:End

Comme dit plus haut, deux caractères hexadécimaux valent un octet, il faut donc lire les datas ci dessus de la manière suivante :
2A ; 0C ; 0D ; 07
Mais maintenant vous savez trouver (très rapidement :-° ) le résultat en décimal :
42 ; 12 ; 13 ; 7

Je pense que vous savez ce qu'il vous reste à faire : pratiquer dès maintenant. :)

Bien sûr cette partie n'est qu'un avant goût de ce qui vous attend au prochain chapitre ; je vous demanderais de ne pas cliquer sur suivant tant que vous ne vous êtes pas entraîné sur la création et la manipulation des datas vus dans ce chapitre, c'est nécessaire pour pouvoir suivre le chapitre suivant ! :pirate:

Mon premier sprite

Avec toutes les connaissances que vous avez vues dans les chapitres précédents, nous allons continuer d'explorer l'univers des datas ; en commençant par les sprites et les tiles.

En Axe, les sprites et les tiles sont des images 8*8 pixels que l'on peut manipuler pour faire un personnages ou des décors.

La théorie

Pour créer un sprite, il faut vous munir d'un éditeur de sprite : autrement dit juste de quoi dessiner. ;)
Vous pouvez donc prendre une feuille et un crayon ou dans mon cas j'utilise paint (il existe des éditeurs de sprites sur calculatrice également).
Le principe est simple : créer une feuille de dessin de 8*8 pixels :

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Dans mon cas, je vais dessiner une émoticône souriante :) en noir et blanc

:

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Vous remarquerez qu'il n'y a que 2 possibilités : soit blanc, soit noir. De plus chaque ligne est composée de 8 pixels. Je suis sûr que cela vous rappelle quelque chose. ^^ Non ?
Les couleurs ressemblent grandement au binaire : le blanc vaut 0 et le noir vaut 1 !
Et pour chaque ligne il y a 8 possibilités : une ligne est égale à un octet !

Maintenant, essayez de me donner la valeur hexadécimale du sprite, en mettant les nombres obtenus de chaque ligne à suivre. :)

D'abord on recrée notre tableau en remplaçant les couleurs par les chiffres binaires correspondants :

Puis on reprend nos outils de conversion pour mettre tout cela en hexadécimal (rappel : 4 chiffres binaires valent 1 chiffre hexadécimal) :

Et on met le tout à suivre, entre des crochets :

:[3C42A581A599423C]

Et voilà votre premier sprite !

La pratique

Pour l'afficher, c'est très facile : on pointe notre data, on utilise les commandes permettant de dessiner les sprites dans le buffer, et on affiche le buffer.

:[3C42A581A599423C]→Pic1
:.On utilise les pointeur Pic pour les sprites
:ClrDraw
:0→X→Y
:Pt-On(X,Y,Pic1
:DispGraph

La commande Pt-On( permet d'afficher le sprite sans effacer les pixels qui sont déjà allumés : seuls les points noirs du sprite s'affichent. L'angle haut gauche du sprite s'affiche à l'emplacement (X,Y).

La seconde commande est la commande Pt-Off( (

). Cette commande permet d'afficher le sprite en effaçant tout ce qu'il y avait avant dans l'emplacement de celui-ci :

:[3C42A581A599423C]→Pic1
:ClrDraw
:0→X→Y
:Pt-Off(X,Y,Pic1
:RectI(20,20,16,16
:Pt-Off(24,24,Pic1
:DispGraph

Ce code va d'abord afficher le sprite en haut à gauche, puis un carré de côté 16 aura en son centre le sprite ; elle aura effacé tous les pixels du centre de ce carré avant d'être dessinée.

La dernière commande permet d'inverser les pixels correspondant au sprite :

:[3C42A581A599423C]→Pic1
:ClrDraw
:0→X→Y
:Pt-Change(X,Y,Pic1
:RectI(20,20,16,16
:Pt-Change(24,24,Pic1
:DispGraph

Cette fois on verra le sprite au centre du carre, mais avec les couleurs inversées.

C'est exactement pareil que pour les fonction de géométrie, il faut rajouter le r juste après :
Pt-On()r
Pt-Off()r
Pt-Change()r

exercice

Essayez de faire un programme qui affiche notre sprite se baladant à travers l'écran (sans en sortir !) à l'aide de la commande Pt-Change(.

:.PLOP
:[3C42A581A599423C]→Pic1
:ClrDraw
:0→X→Y
:Rect(28,24,32,32
:Repeat getKey(15)
:(getKey(3) and (X≠88))-(getKey(2) and (X≠0))+X→X
:(getKey(1) and (Y≠56))-(getKey(4) and (Y≠0))+Y→Y
:.Déplacement de X et Y
:sub(CHG)
:.On inverse les pixels du sprite avant d'afficher (on la dessine dans le buffer)
:DispGraph
:sub(CHG)
:.On inverse les pixels du sprite après avoir affiché (on efface le sprite par double inversion)
:End
:Return
:
:Lbl CHG
:Pt-Change(X,Y,Pic1

Le tilemapping

Vous attendiez sûrement ce moment avec impatience, mais le voici : vous êtes capable, à l'aide de vos connaissances, de créer une map composée de tiles 8*8, et de l'afficher à l'écran ! :D

Je vais vous orienter un peu bien sûr. :magicien:

création de la map

Comme pour les sprites, une map ne s'improvise pas, il faut la dessiner avant.
Dans mon cas j'ai fait vite fait une maison et de l'herbe :

L'herbe :

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Le code hexadécimal est donc :
[0044888800112222]

Maison haut gauche :

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Le code hexadécimal est donc :
[0107196181818181]

Maison haut droite :

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Le code hexadécimal est donc :
[80E0988681818181]

Maison bas gauche :

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Le code hexadécimal est donc :
[818698E09E929692]

Maison bas droite :

Pxl	1	2	3	4	5	6	7	8
1
2
3
4
5
6
7
8

Le code hexadécimal est donc :
[8161190771517101]

Donc on a dans l'ordre :

:[0044888800112222]→Pic1
:.Herbe
:[0107196181818181]
:.Maison haut/gauche
:[80E0988681818181]
:.Maison haut/droite
:[818698E09E929692]
:.Maison bas/gauche
:[8161190771517101]
:.Maison bas/droite

Sur ce principe, on affiche de la manière suivante les tiles :

:Pt-On(X,Y,Pic1+0
:.Herbe
:Pt-On(X,Y,Pic1+8
:.Maison haut/gauche
:Pt-On(X,Y,Pic1+16
:.Maison haut/droite
:Pt-On(X,Y,Pic1+24
:.Maison bas/gauche
:Pt-On(X,Y,Pic1+32
:.Maison bas/droite

Comme pour les chaînes de caractères, on peut manipuler les pointeurs pointant des tiles.

On remarque tout de suite que 0, 8, 16, 24 et 32 sont multiples de 8 : 0*8, 1*8, 2*8, 3*8 et 4*8.
Le seul nombre changeant peut être une variable, on obtient donc la simplification suivante :

:.La variable A vaut la valeur de la tile correspondante
:Pt-On(X,Y,A*8+Pic1

L'écran est composé de 96 pixel fois 64 pixels : soit 12*8 pixels et 8*8 pixels. On peut donc faire une carte 12*8 composé de tiles 8*8. :soleil:

Dans mon cas, je mettrai une maison au milieu et de l'herbe partout autour :

:[000000000000]→GDB1
:[000000000000]
:[000000000000]
:[000001200000]
:[000003400000]
:[000000000000]
:[000000000000]
:[000000000000]
:.8 ligne fois 12 caractères par ligne.

Et voilà, tous les éléments sont réunis pour afficher notre tilemap !

Affichage de la tilemap

C'est là que les choses se corsent, on a pour l'instant ce code :

:[0044888800112222]→Pic1
:.Herbe
:[0107196181818181]
:.Maison haut/gauche
:[80E0988681818181]
:.Maison haut/droite
:[818698E09E929692]
:.Maison bas/gauche
:[8161190771517101]
:.Maison bas/droite
:
:[000000000000]→GDB1
:[000000000000]
:[000000000000]
:[000001200000]
:[000003400000]
:[000000000000]
:[000000000000]
:[000000000000]

La méthode que je vous présente consiste à afficher ligne par ligne chaque tile 8*8 à son emplacement donné dans l'écran comme vu plus haut (12*8). Pour cela j'utiliserai un système de double boucle avec les variables X et Y :

:For(Y,0,7)
:For(X,0,11)
:Pt-On(X*8,Y*8,EXP)
:End
:End

EXP désignant l'expression (le calcul) à faire pour obtenir la tile voulu.

Une commande nous arrive alors, tout cuit dans le bec : la commande nib{ }. Cette commande est très utile dans le tilemapping car elle permet de récupérer un quartet (en Anglais nibble), soit une moitié d'octet, donc un seul caractère hexadécimal.

On va donc passer en argument à la commande l'adresse du quartet à renvoyer.

Par exemple, pour avoir le deuxième quartet de GDB1 (pour nous la deuxième tile à afficher), on va procéder comme ceci :

nib{GDB1*2+1}

Grâce à cette commande, nous allons pouvoir extraire toute notre tilemap à l'aide d'une seule expression. Et n'attendons plus, cette expression est :

nib{lignes * tilesParLigne + colonne + (ptrMap * 2)}

Lorsque le nombre de tilesParLigne est paire on peut simplifier en :

nib{tilesParLigne / 2 * lignes + ptrMap * 2 + colonne}

Vous ne pouvez que comprendre puisqu'on vient à l'instant même de dire comment cela fonctionnait. ^^

Si on reprend notre boucle, Y indique le numéro de la ligne et X le numéro de la colonne. Quand au nombre de tiles par ligne il va être de 12 quartets, soit 6 octets. On obtient finalement :

:.TILEMAP
:
:[0044888800112222]→Pic1
:.Herbe
:[0107196181818181]
:.Maison haut/gauche
:[80E0988681818181]
:.Maison haut/droite
:[818698E09E929692]
:.Maison bas/gauche
:[8161190771517101]
:.Maison bas/droite
:
:[000000000000]→GDB1
:[000000000000]
:[000000000000]
:[000001200000]
:[000003400000]
:[000000000000]
:[000000000000]
:[000000000000]
:
:For(Y,0,7)
:For(X,0,11)
:nib{Y*6+GDB1*2+X}→A
:Pt-On(X*8,Y*8,A*8+Pic1)
:End
:End
:
:.Une boucle pour l'affichage
:Repeat getkey(15)
:DispGraph
:End

Un petit screen pour donner un aperçu :

Voici votre première tilemap !

Encore plus de Data !

Par la suite on utilisera les Datas pour faire de la musique, des jeux multijoueurs,... ils envahiront vos programmes. :diable:

Pour vous faciliter la vie, il existe plusieurs outils pour manipuler et exploiter les Datas au maximum.

Modifier nos Datas

Je vous ai déjà dit que nos datas pouvaient se manipuler comme des variables d'un octet, mais je ne vous ai pas montré d'exemple :

:[09]→GDB9                :.L'octet que pointe GDB9 vaut 9
:Disp {GDB9}▶Dec        :.On affiche 9
:18→{GDB9}                :.On modifie la valeur du premier octet pointé par GDB9 à 18
:Disp {GDB9}▶Dec        :.On affiche 18

Non !
En fait, le gros avantage des Datas c'est que les données enregistrées seront toujours stockées dans l'exécutable. Du coup, on peut les modifier, quitter le programme, éteindre la calculatrice, la rallumer, revenir dans le programme, et elles seront toujours là ! :ninja:

On peut également manipuler 2 octets à la fois pour avoir un nombre entre 0 et 65535. Votre Data devra juste avoir un ʳ juste après la fermeture des accolades.

:[FFFF]→GDB9
:
:Disp {GDB9}▶Dec        :.Affiche 255
:Disp {GDB9}ʳ▶Dec        :.Affiche 65535

Pour modifier sa valeur c'est exactement pareil :

:10012→{GDB9}ʳ

On peut même manipuler 2 octets... inversés :D . Il faut pour cela utiliser un deuxième ʳ à la suite du premier :

:[0100]→GDB9
:
:Disp {GDB9}ʳ▶Dec        :.Affiche 1
:Disp {GDB9}ʳʳ▶Dec        :.Affiche 256 (sois 0100 en hexadécimal)

La commande lenght(

La commande lenght( (signifiant littéralement "longueur") permet de calculer le nombre d'octets qui suivent à partir d'un octet donné, et jusqu'au prochain octet qui vaut 0 non compris.
Voici un exemple concret d'utilisation :

:Data(11,22,42,31,0)→Pic12
:lenght(Pic12)→A
:For(Z,0,A)
:Output(0,Z,{Pic12+Z}▶Dec
:End
:.11, 22, 42, 31 et 0 sont affichés sous forme de colonne

Le nombre d'octets trouvé déterminera le nombre de fois que la boucle va se répéter en affichant à chaque fois un nouvel octet.

Rechercher une valeur dans les Datas

De la même manière que la commande lenght(, la commande inData( permet de trouver l'emplacement de l'octet cherché :

:Data(11,22,42,31,0)→Pic12
:inData(42,Pic12)→A
:For(Z,0,A-1)
:Output(0,Z,{Pic12+Z}▶Dec
:End
:.11, 22 et 42 sont affichés sous forme de colonne

Si l'octet recherché n'est pas trouvé, alors la valeur 0 est renvoyé, ou sinon la commande renvoie l'emplacement de l'octet trouvé en commençant par 1, puis 2, puis 3, etc.

Avant de clôturer ce chapitre, je tiens à vous montrer un code grandement simplifiable grâce à la commande inData( :

:If A=1 or (A=3) or (A=10) or (A=12)
:.Code
:End

Ce code peut donc s'écrire comme ceci :

:If inData(A,Data(1,3,10,12,0))
:.Code
:End

Ce chapitre est sans doute le plus difficile pour cette deuxième partie ; ne le négligez pas car c'est ici que repose une grande partie de la puissance de l'Axe Parser.
Plus tard vous apprendrez même à faire des datas pour la musique, les grayscales,... le principe reste le même, mais l'utilisation est différente.

présentation des listes

Une liste est une partie de la mémoire dans laquelle on peut stocker des informations durant l'exécution du programme. C'est comme des Datas qu'on ne voudrait pas garder.
Il y en a 6 en tout, et chacune est utilisée régulièrement par la calculatrice : en fonction de vos programmes toutes les listes ne sont pas exécutables.

La liste 1 L1 : saveSScreen

L1 se trouve ici :

"saveSScreen" pour les intimes, cette liste est la plus sûre. Elle permet d'utiliser 714 octets.

Non, L1 est un simple pointeur, les octets qui le suivent s'utilisent comme les Datas :

:12→{L1}
:Disp {L1}▶Dec
:.Affiche 12
:
:42→{L1+1}
:Disp {L1+1}▶Dec
:.Affiche 42

Les octets d'une liste sont toujours inconnus au démarrage d'un programme, donc il est recommandé de les initialiser au démarrage du programme. Dans le cas où l'on veut utiliser tous les octets de L1 :

:For(Z,0,713)
:0→{L1+Z}
:End

La liste 2 L2 : statVars

De son vrai nom "statVars", cette liste a une longueur de 531 octets. Il y a un risque si elle est utilisée en même temps qu'une interruption personnalisée, notamment si vous utilisez MirageOS.
La manière de l'utiliser est la même que pour toutes les autres listes, ici l'exemple de l'initialisation :

:For(Z,0,530)
:0→{L2+Z}
:End

L2 se trouve ici :

La liste 3 L3 : appBackUpScreen

En fait vous connaissez déjà cette liste... mais sous un autre nom : le back-buffer. En effet, cette mémoire permet de sauvegarder l'écran entièrement, elle est constituée de 768 octets.

Exactement ! ^^
Rappelez vous, 96*64=6144 pixels, soit 6144 bits. Donc pour trouver combien cela fait en octet, il faut faire 6144/8 soit 768.

Du coup, cette liste ne doit pas être utilisée si vous utilisez le back-buffer pendant votre programme.
Le code pour initialiser serait :

:For(Z,0,767)
:0→{L3+Z}
:End

L3 se trouve ici :

La liste 4 L4 : tempSwapArea

Cette liste est utilisée lorsque vous archivez ou désarchivez un programme par exemple (chose que nous verrons dans la troisième partie :ange: ). Elle permet d'utiliser 256 octets, donc en reprenant notre exemple d'initialisation :

:For(Z,0,255)
:0→{L4+Z}
:End

L4 se trouve ici :

La liste 5 L5 : textShadow

Lorsque vous affichez du texte à l'écran, c'est cette liste qui est utilisée : il est donc recommandé de ne pas afficher de texte à l'écran pendant son utilisation (mais on peut l'utiliser distinctement ;) ). Elle fait 128 octets.

:For(Z,0,127)
:0→{L5+Z}
:End

L5 se trouve ici :

La liste 6 L6 : plotSScreen

Cette liste est la plus utilisée de toutes : c'est la mémoire du buffer. Celui-ci est utilisé fréquemment dans les programmes en Axe, du coup son utilisation reste assez spécifiée. Comme pour le back-buffer, il y a 768 octets :

:For(Z,0,767)
:0→{L6+Z}
:End

L6 se trouve ici :

Les tableaux

Les tableaux, ce n'est qu'une manière particulière de manipuler les listes... ou les Datas ! Cela ne vous rappelle rien ?
Lorsque vous afficher une tilemap dans le buffer :

:For(Y,0,7)
:For(X,0,11)
:{Y*6+X+GDB1}→A
:...
:End
:End

Ceci est un tableau d'abscisse X et d'ordonné Y ! ;)

En général on établit un tableau de la manière suivante : {<Numéro de la ligne>*<Nombre total de colonne>+<Numéro de la colonne>+<Pointeur>}
Soit en Axe :

:...
:GDB1 le pointeur
:Y le numéro de la ligne
:X le numéro de la colonne
:T le total de colonne par ligne
:...
:{Y*T+X+GDB1}

Pour naviguer dans le tableau, il suffit de modifier les axes X et Y.

D'autres commandes utiles

Toutes les commandes vues pour les Datas peuvent être utilisées pour les listes. De même les commandes qui vont suivre peuvent être utilisées pour les Datas.

Copier les octets avec la commande Copy

Cette commande permet de copier un nombre d'octets à partir d'un pointeur, vers le même nombre d'octets suivant un autre pointeur.

Elle prend donc trois arguments, dans l'ordre : le pointeur de départ (Str1), le pointeur d'arrivé (L1), le nombre d'octet (A) :

:Copy(Str1,L1,A)

Par exemple, je peux recréer facilement la commande RecallPic :

:Copy(L3,L6,768)

De la même manière, il existe une commande pour copier les octets à partir de la fin : Copy()ʳ

Échanger les octets

Oui, on peut même échanger les octets ! Les arguments sont exactement les mêmes que pour la commande Copy(, seulement il faut utiliser la commande Exch( :

puis 4 fois sur le touche

et appuyez sur

Reprenons notre buffer et notre back-buffer, il n'existe pas de commande implémentée pour les échanger, on peut donc facilement créer une fonction :

:. Échanger le buffer et le back-buffer
:Lbl CHB
:Exch(L3,L6,768)
:Return

Remplir les octets

La commande Fill( est de celles qui nous facilitent la vie :D . Elle permet de remplir à partir d'un octet, tous ceux qui suivent (jusqu'à un nombre en argument) par la valeur du premier. Traduction, le code que l'on a vu pour initialiser les valeurs de L1 à 0 :

:For(Z,0,713)
:0→{L1+Z}
:End

Peut s'écrire plus simplement avec la commande Fill( :

:0→{L1}
:Fill(L1,713)

Votre cours pour la deuxième partie est terminé... mais un petit TP vous attend ! :p
Relisez une dernière fois ce chapitre avant de continuer. ;)

Présentation du jeu

Le contexte

C'est très important quand vous créez un jeu de ce genre : il vous faut un imaginaire, un contexte.
Dans mon exemple, Zozor a perdu son échiquier. Pour le retrouver, il doit sortir de sa prairie et récupérer le maximum de zéros (le numéro) possible.

Les tiles et les sprites

Après avoir déterminer le contexte, il vous faudra dessiner vos propres sprites !

Rassurez vous, si le dessin n'est pas votre tasse de thé, je vous ai prévu quelques sprites et tiles d'urgence :

• Le sprite de Zozor :

  Pxl	1	2	3	4	5	6	7	8
  1
  2
  3
  4
  5
  6
  7
  8

• La tile de l'herbe :

  Pxl	1	2	3	4	5	6	7	8
  1
  2
  3
  4
  5
  6
  7
  8

• La tile d'un mur :

  Pxl	1	2	3	4	5	6	7	8
  1
  2
  3
  4
  5
  6
  7
  8

• La tile d'une barrière de clairière (horizontal) :

  Pxl	1	2	3	4	5	6	7	8
  1
  2
  3
  4
  5
  6
  7
  8

• La tile d'une barrière de clairière (vertical) :

  Pxl	1	2	3	4	5	6	7	8
  1
  2
  3
  4
  5
  6
  7
  8

• La tile d'une porte prête à être mise dans un mur :

  Pxl	1	2	3	4	5	6	7	8
  1
  2
  3
  4
  5
  6
  7
  8

Le déroulement du jeu

Lorsque l'on démarre le jeu, il faut arriver dans un menu avec de beaux graphismes. On devra pouvoir choisir, à l'aide d'un curseur, si l'on veut jouer, quitter le jeu, ou aller dans les crédits.

Dans le jeu, notre zozor doit démarrer au milieu de sa prairie. La tilemap devra être plus grande que l'écran !
Pour vous aider, voici un exemple de tilemap avec les tiles vues plus haut :