Il suffit de faire : Code : Autre
:GetCalc("varA")→P :float{P}→A :1→float{P}
Ce code stockera la vraie variable A dans la variable Axe A, puis enregistrera 1 dans la vraie variable A. Bien entendu, on ne peut enregistrer que des entiers allant uniquement de 0 à 65535 dans les vraies variables, puisque l'Axe Parser supporte seulement des nombres de 2 octets.
Il n'y a pas besoin d'utiliser r après la commande float si on sauvegarde un nombre de 2 octets.
Encore plus de variables !
En fait toutes les variables de la calculatrices sont manipulables, voici le tableau des tokens à mettre entre parenthèses pour les manipuler :
Exemple Variable
"prgmABC" Le programme ABC.
"appvABC" L'appvar ABC.
"grpABC" Le groupe ABC (seulement archivé).
"LABC" La liste ABC.
"L1" La liste L1
"varA" La "vraie" variable A
"Str1" La chaîne de caractères Str1.
"GDB1" La base de données graphique GDB1.
"Pic1" L'image Pic1.
"Y1" La fonction Y1.
"[A]" La matrice A.
Je fais très vite le tour de ceux qu'on n'a pas encore vus, dans tous les cas le principe reste toujours le même : Les groupes ne sont manipulables qu'avec les fichiers.
Les listes sont composées de nombres réels, pour afficher le nombre de nombres réels dans cette liste : Code : Axe
:GetCalc("L1")→A :Disp {A-2}r▶Dec
Les chaînes de caractères (String) sont de simples chaînes de caractère tokens. On peut obtenir la longueur d'une String en lisant les deux octets se trouvant avant celle ci :
Code : Axe
:GetCalc("Str1")→A :Disp {A-2}r▶Dec
Les bases de données graphiques font 117 octets.
Les images (Pic) de base font 756 octets seulement car la ligne du bas est ignorée.
Les fonctions (Y1, Y2,...) sont également des chaînes de tokens, elles se terminent par un zéro.
Les matrices ([A], [B],...) sont constituées de nombres réels, la largeur X*Y de la matrice se retrouve dans les deux octets précédent celle-ci :
Code : Axe
:GetCalc("[A]")→A :Disp {A-1}▶Dec :.X :Disp {A-2}▶Dec :.Y
Les variables cachées
Si, dans un programme vous craignez de manquer de variables car elles risquent d'être utilisées par un autre programme, il vous reste une solution : les variables cachées, ou hackées.
QUOI !? On m'a toujours dit que c'était pas bien de hacker !
Ici, pas de question de pirater quoi que ce soit, mais bien d'utiliser des choses qui nous sont littéralement cachées.
Attention cependant : l'utilisation des variables hackées peut conduire à de petits bugs comme un remplissage incompréhensible de la RAM, à des RAM cleared (au pire) ou encore des situations étranges telles que celle-ci :
Gnéééé !?
Ah bah génial, pour l'instant tu nous as présenté que des inconvénients ... Y'a des avantages au moins ?
L'avantage, il est de taille, car tenez-vous bien ...
Grâce à cette méthode, vous allez avoir 256 pics, 256 GDB, 256 variables et 256 fois tout autres variables dont le nom n'est pas modifiable, et ce à disposition pour votre programme seulement !!
En gros, vous allez pouvoir manipuler tellement de variables de la calculatrice que vous ne saurez plus quoi en faire.
Le secret des chaînes de caractère
Précédemment, quand on voulait accéder à par exemple Pic1, on faisait comme ça : Code : Axe
:GetCalc("Pic1")→A :.C'est le token Pic1
Ici, on pointe en premier argument à GetCalc() une chaîne contenant les informations pour trouver la variable de la calculatrice désirée. Il suffit donc d'étudier les octets de cette chaîne.
Je viens de regarder sur ce site, pour Pic1 le token va être [6000].
C'est une très bonne trouvaille, cela va nous servir par la suite. Seulement il y a un problème, l'Axe Parser rajoute deux octets lors de la compilation : le premier est le zéro de fin de chaîne de caractère ; et le deuxième est rajouté en début de chaîne, c'est le type de la variable !
Les différents types de variables
Vous l'aurez compris, on cherche à utiliser les variables de la calculatrice en manipulant leurs octets : Le type de la variable (1 octet).
Le nom de la variable (variant).
Le zéro de fin de chaîne de caractère.
Premièrement, le type de la variable. Il y en a un paquet, alors voici un tableau pour résumer tout ça :
HEX Type
00 Nombre réel 01 Liste 02 Matrice 03 Équation 04 Chaîne de caractère 05 Programme 06 Programme protégé 07 Image (Pic)
08 Base de donnée graphique (GDB) 0B Nouvelle équation
0C Nombre complexe 0D Nombre complexe 14 Application
15 Appvar
16 Programme temporaire
17 Groupe
La présence de deux types pour spécifier un complexe vous donne deux fois plus de tokens, donc 512 Complex à disposition.
Cet octet de type va donc renseigner le type de variable à laquelle on va accéder. Il faut ensuite faire suivre cet octet par le nom de la variable.
Le nom des variables Il y a deux catégories de noms de variables :
Les noms modifiables (Groupe, programme, programme temporaire, programme protégé, appvar, application et les listes).
Les noms non-modifiables (nombre réel, matrice, équation, chaîne de caractère, image, base de donnée graphique, nouvelle équation et nombre complexe).
Le principe est très simple, pour la première catégorie il suffit de mettre le type suivit du nom : Code : Axe
:[15]"ABC"→Str1
:.Cela revient au même que :"appvABC"→Str1[
Pour la seconde, c'est plus compliqué. En fait il faut indiqué le token de la variable comme nom, pour cela je vous conseil de regarder ici.
Essayons avec Pic1 de token [6000] : Code : Axe
:[0760]→Str1 :Data(0,0)→Pic1X
:.Cela revient au même que :"Pic1"→Str1
Les variables hackées
Pourquoi il y a un pointeur Pic1X de rajouté ?
En fait en modifiant l'octet pointé par Pic1X on peut naviguer aisément entre les différentes Pics de la calculatrice !
Mais ce n'est pas le seul avantage : cet octet peut prendre 256 valeurs, on a donc accès à 256 Pics de la calculatrice. Ce sont des variables qui n'existe pas normalement, et on les appelle variables hackées !
Le problème de ces variables est qu'elles ne sont pas reconnues par l'OS, mais elles peuvent très bien être utilisées dans un programme en Axe. Voici l'équivalent de la chaîne de caractère Str100 :
Code : Axe
:[04AA]→Str100 :Data(100,0)
Et pareil pour tous les autres types de cette catégorie !
Les groupes et les applications ne se manipulent qu'avec les fichiers.
Donc les deux principaux intérêts des variables hackées pour les noms non-modifiable : pouvoir utiliser 256 variables de chaque type ; et pouvoir naviguer assez facilement entre les variables d'un même type en modifiant un octet.
Grâce à tout cela, vous pourrez créer highscores, achievements et même plugins pour des programmes déjà existants !