Les membres ayant 30 points peuvent parler sur les canaux annonces, projets et hs du chat.
La shoutbox n'est pas chargée par défaut pour des raisons de performances. Cliquez pour charger.
Tous | Tutoriels du Mercredi | Basic Casio | C/C++/ASM | LuaFX | Graphisme | Transferts | Logiciels | Diverses astuces

Calculatrice
Toutes
Graph 35 à 100
Graph 25+Pro/25+E/25+E II
Graph 35+USB/75(+E)/85/95 SD
Graph 100(+)
Classpad 300/330(+)
fx-CG 10/20 (Prizm)
Classpad 400(+E)
Graph 90+E
fx-92+ SC

Retour à la liste des tutoriels
Tutoriel Casio : TDM 02 : Manipulez les Listes avec adresse !
Tutoriel rédigé le : 2018-09-02 16:58  par Drak  Catégorie : Tutoriels du Mercredi  Calculatrice : Toutes

Discutez de ce tutoriel sur le forum >> Voir le sujet dédié (27 commentaires)

TDM 02 : Manipulez les Listes avec adresse !
Le Tuto Du Mercredi [TDM] est une idée qui fut proposée par Ne0tux. Voici le principe : un mercredi sur deux, nous postons un petit tutoriel sur l'Utilisation de la calculatrice, le Transfert, la Programmation, ou encore la Conception de jeu ! En voici donc la deuxième édition ! (une édition bien grosse !)

Manipulez les Listes avec l'adresse d'un expert ! (BASIC)

Niveau : ★ ★ ★ ☆ ☆

Les listes sont des suites de valeur que l'on appelle via la fonction List. Celles-ci sont visible dans le menu STAT de la calculatrice. Elles sont très pratiques et souvent utilisées pour des suites logiques de variables, des sauvegardes de jeu, du DrawStat et bien plus encore. Nous allons donc explorer les techniques à connaître pour profiter du potentiel des Listes !


Partie I : Initialiser une liste

Il existe plusieurs manières d'initialiser des listes. Il est préférable de toutes les connaître pour choisir la bonne méthode en fonction de vos besoins ! La première méthode, la plus évidente, est celle-ci :
{1, 5, 3} → List 1
Dans cet exemple, j'attribue respectivement les valeurs 1, 5 et 3 dans les cases 1, 2 et 3 de la liste 1. Cela effacera tout le contenu de la liste 1 pour le remplacer par ces trois valeurs.

/!\ Attention : le premier index d'une liste en Basic Casio n'est pas 0 mais 1. Vous rencontrerez une Memory Error si vous tentez de rentrer un nombre en List1[0]. Vous verrez plus tard à quoi sert List 1[0] en réalité.

3 → Dim List 1
Cette méthode est redoutablement efficace. Elle réinitialise la liste en lui attribuant une nouvelle dimension : autrement dit, cette ligne me donnera une liste de 3 cases. Chaque case se voit attribuer la valeur 0. En quelques octets, vous pourrez donc remplir une centaine de cases de zéros aisément. Cela vous permet aussi d'anticiper les Dim Error, puisque vous saurez précisément jusqu'où s'étend votre liste.

"MALISTE1" → List 1 [0]
« Quoi ? On peut mettre des chaînes de caractères dans une liste ? À l'indice 0, qui plus est ?! » Alors. Laissez-moi vous expliquez cette méthode : une liste peut avoir un nom. Oui, un nom, donc une chaîne de caractères. Et, ce nom, sachez qu'il est contenu dans la case 0 de la liste. Vous pouvez le voir dans le menu STAT :

En employant cette commande, vous donnez donc un nom à la liste. Attention toutefois à ne pas dépasser les 8 caractères. Si cette liste contient déjà des valeur, cette méthode n'affectera pas le contenu. En revanche, si la liste est vide, cette méthode attribuera la valeur 0 à la case 1. Autrement dit, c'est une excellente méthode pour vérifier si votre liste est vide ou non en évitant le Dim Error. Pour plus de sûreté, vous pouvez aussi vérifier que votre Liste a les dimensions attendues.
"MYLIST" → List 6 [0]
If List 6 [1] != 0 And Dim List 6 = 5: Then //Si la première case n'égale pas zéro, c'est que la liste était déjà remplie. Ma liste est aussi censée faire 5 cases.
// Donc... Tout va bien.
Else //Sinon, ça pue.
« Error : No List. »
Stop
IfEnd

//Le même code, un peu optimisé :
"M" → List 6 [0
If List 6 [1 : Then
// Tout va bien
Else
« Error : No List. »
Stop
IfEnd
Sachez que vous pouvez également appeler une liste par son nom plutôt que par son indice :
1 → List "MALISTE" [1]
3→Dim List "MALISTE"
etc.

Il existe encore d'autres méthodes moins répandues, comme celle-ci :
Seq(X^2, X, 1, 10, 1) → List 1  
La description de la fonction Seq( se trouve ici. Elle permet de rentrer une séquence de nombres dans une liste. La fonction prend les arguments suivants :
Seq( Expression/Fonction mathématique à exécuter, Variable utilisée pour la fonction, Première valeur de la variable à utiliser, Dernière valeur de la variable, Le pas (de 1 en 1, de 2 en 2, de 0,55 en 0,55...) ) → List 1

Dans mon exemple, je remplis donc dix cases avec les résultats de la fonction f(x) = x², en partant de x=1 jusqu'à x=10 et en allant de 1 en 1. J'aurai donc cette liste comme résultat :
{1, 4, 9, 16, 25, 36, 49, 64, 81, 100}
En résumé, cette fonction génère une liste à partir d'une expression dépendant d'une variable.

{1, 3, 5, 15}
Il est aussi possible d'écrire une liste sans l'attribuer. Cette ligne remplira en fait la List Ans, ce qui est utile si vous manipulez une liste pour un court moment (comme un Drawstat). Vous pouvez appeler la List Ans de la même manière que les autres listes, à condition bien sûr qu'elle ne soit pas vide.


Partie II : Le calcul listique

Parce que listique rime avec balistique, ce chapitre pourrait faire frémir certains d'entre vous. Rassurez-vous jeunes gens, le calcul listique n'est pas très dur à comprendre. Suivez-moi !

Pour commencer, voici un exemple de calcul listique :
List 1 [2] + List 1 [3] → List 6[1]
Ici, rien de bien compliqué ! On se sert des cases des listes exactement de la même manière que des variables. J'additionne la valeur de la case 2 de la liste 1 avec la valeur de la case 3 de la liste 1 pour attribuer le résultat à la case 1 de la liste 6. Du point de vue de la forme, ça serait la même chose que « A + B → C ».

15 + List 1 → List 1
// ou encore
15 + {1, 3, 5} → List 1
« Heu... »
Mais non ! Tout va bien ! Cette ligne assez particulière ajoute 15 à l'ensemble des valeurs de la liste 1. Autrement dit, j'aurai ce résultat :
{16, 18, 20}
À partir de là, vous pouvez tout envisager : additions, soustractions, multiplications, divisions.

Mais c'est là que ça devient encore plus tordu !
List 1 + List 2 → List 3
//ou bien
{12, 5, 6} + {20, 0, -10} → List 3
Vous ne rêvez pas : il est également possible de faire des calculs avec des listes entières ! Attention toutefois ; ces listes doivent IMPÉRATIVEMENT avoir la même dimension, autrement c'est l'erreur fatale. Cette méthode permet donc d'additionner chaque case une à une, comme indiqué dans ce schéma :

À partir de là, je peux vous montrer comment faire une liste de valeurs complexes, utiles pour stocker des coordonnées :
{10, 12, 4, 5, 0} + i {2, 3, 10, 0, 12} → List 1

Sachez aussi que vous pouvez faire des conditions avec des listes ! On plonge encore plus dans le délire !
{25,10,0,-85,-2,2,100000, -1} → List 1
List 1 < 0 → List 2
Cette deuxième ligne permet de faire vérifier une condition sur toutes les valeurs de la List 1. Autrement dit, cette deuxième ligne renvoie une liste de booléens. « 0 » si la condition demandée et fausse, « 1 » si cette dernière est vraie. List 2 contient donc ceci :
{0,0,0,1,1,0,0,1}

Si vous ne comprenez pas, ça reviendrait à faire la même chose que ce code :
For 1 → A To Dim List 1
If List 1 [A] < 0 : Then
1 → List 2 [A]
Else 0 → List 2 [A]
IfEnd
Next
Puissant, hein ?


Partie III : Optimiser, économiser, compresser.

Dans cette partie, nous allons parler d'une chose essentielle, nécessaire même, en Basic Casio : l'optimisation. Il est important de savoir qu'une liste, ça prend de la place. Écrire une suite de nombres dans la code à attribuer à une liste, ça prend de la place aussi. Nous allons voir comment gagner / économiser des octets lorsqu'on utilise des listes.

1) Chaque case a un poids.

Sachez que lorsque vous attribuez un réel à une case, celle-ci occupera 12 octets dans la mémoire de la calculatrice. Un nombre complexe, quant à lui, occupera 24 octets ! Voici un bout de code qui pèse 24 octets :
"Je suis une banane !!!"
Ce n'est pas négligeable. Donc, lorsque vous stockez des coordonnées pour votre Drawstat, plutôt que d'occuper 24 octets par points (soit en complexes, soit en ayant deux listes pour les abscisses et les ordonnées), il existe une technique pour n'en prendre que 12 par points. Vous êtes prêts ?
{10, 12, 4, 5, 0} + i * {2, 3, 10, 0, 12} → List 1 //24 octets par cases.
{10.02, 12.03, 4.10, 5.00, 0.12} → List 1 //12 octets par cases.
//En plus optimisé :
{10.02, 12.03, 4.1, 5, .12} → List 1
L'astuce consiste à stocker l'abscisse de chaque point dans la partie entière du nombre et l'ordonnée dans la partie fractionnaire. Il faut cependant partir du principe que les ordonnées de vos points sont comprises entre 0 et 99. Rien ne vous empêche d'intervertir les deux. Pour ensuite extraire les valeurs de vos cases, vous pouvez faire ceci :
Int List 1 //toutes les parties entières des valeurs
100 Frac List 1
// ou encore :
E2 Frac List 1 //toutes les parties fractionnaires des valeurs

Ensuite, dans d'autres cas, vous n'avez que des petites valeurs à stocker, comme des suites de 0 et de 1 ou bien des chiffres compris entre 0 et 9. Par exemple, mettons que j'aie des caractéristiques de base à distribuer à mon héros dans un RPG, chacune comprise entre 0 et 9. Avec 6 caractéristiques, par exemple, voici ce qu'on serait tenté de faire dans l'immédiat :
{2, 2, 4, 5, 6, 7} → List 1
// Dans l'ordre : PV, Attaque, Défense, Attaque Spé, Def. Spé, Vitesse.
Cette liste occupera 72 octets dans la mémoire de votre calculatrice. Voici maintenant ce que vous pourriez faire :
224567 → List 1 [1]
Non seulement ces informations ne prendront que 12 octets dans la liste, mais en plus vous économisez des octets en n'écrivant pas les accolades et les virgules. Pour récupérer chaque valeur individuellement, vous pouvez avoir recours à cette formule :
MOD(Int (A/10^(n-1)),10)
Cette dernière vous donnera le nième chiffre de A. Je ne vais pas rentrer dans les détails de cette formule. Poursuivons notre chemin !

Enfin, si vous n'avez plus besoin d'une liste de valeurs, alors ne la laissez pas prendre de la place inutilement sur votre mémoire. N'oubliez donc jamais cette commande :
ClrList 1

2) Il n'y a pas de « petites » optimisations !
Depuis le début de ce topic, j'ai fait en sorte d'écrire « proprement » chaque ligne de code, c'est à dire de ne pas y faire d'optimisations étranges. Il y a une chose que l'on peut faire en Basic Casio, qui pourtant serait intolérable dans un quelconque langage de programmation : se passer des accolades, crochets et parenthèses finales. À partir de maintenant, ne faites plus :
{10, 12, 4, 5, 0} + i * {2, 3, 10, 0, 12} → List 1
Mais faites :
{10, 12, 4, 5, 0} + i {2, 3, 10, 0, 12 → List 1
De même, ne faites plus :
10 * Int (List 1 [2] + List 1 [3]) → List 6[1]
Mais faites :
10Int (List 1 [2] + List 1 [3 → List 6[1

Je sais. C'est moche, mais on gagne des octets, eh ! Pour plus d'informations, consultez cette page.

3) Soyez malin, soyez radin !
Ne laissez jamais passer une occasion de gagner de la place. Mettons que vous vouliez hardcoder (écrire directement dans le code) une liste comme celle-ci :
{10, 12, 14, 15, 10, 12, 13, 20, 10, 12} → List 1
C'est l'occasion d'utiliser le calcul listique pour gagner de la place ! En avant, toutes !
10 + {0, 2, 4, 5, 0, 2, 3, 10, 0, 2 → List 1 // 7 octets gagnés !

Ou bien une liste comme ça :
{420, 150, 980, 1000, 10 000, 122, 540} → List 1 // avant
10{42, 15, 98, E2, E3, 12.2, 54 → List 1 //après !

Poussons le vice !
{10, 15, 8, 6, 12, 13, 11, 11, 7, 7} → List 1 //Avant...
6+{4, 9, 2, 0, 6, 7, 5, 5, 1, 1 → List 1 //Après...
//Toutes mes valeurs sont comprises entre 0 et 9 ! Alors...
4920675511 → List 1 [1
//Pour retrouver le nième chiffre...
6 + MOD(Int (List 1 [1]/10^(n-1)),10)
// Vous remarquerez que cette dernière ligne peut paraître lourde, mais elle représente un gain de place conséquent quand elle est appliquée sur plusieurs variables de ce type.


Partie IV : Application directe.

1) Faire une sauvegarde de jeu.
Dans beaucoup de jeux différents, il est nécessaire de sauvegarder des données de jeu : un score, des caractéristiques, une avancée de quête, des accomplissements... On évitera de laisser ces données dans les variables alphanumériques qui pourraient très facilement être changées par un autre programme ou par l'utilisateur. On pourrait décider de stocker ces données à sauvegarder dans une liste, ce qui est judicieux, mais il y a toujours le risque que le joueur efface ces données par inadvertance. Il existe une solution assez sure pour effectuer une sauvegarde de jeu : la fonction File.
Le réglage List File disponible dans Shift → Menu (Set up)

Saviez-vous que vous avez accès en réalité à 156 listes différentes ? Vous avez en fait 6 fichiers de liste (appelées ListFiles) différents. Vous travaillez avec le fichier 1 par défaut. Voici comment s'en servir :
File 2 //Exploite le deuxième ListFile.
{1, 2, 45 → List 1 //Vous remplissez une liste de valeurs dans le ListFile 2
File 1 //Revient au premier ListFile
ClrList //Efface toutes les listes du ListFile 1, mais pas des autres !

Voici donc un exemple d'application directe, dans le cas où les données à sauvegarder se situent dans List 5 sur le fichier 1.
//Quand j'effectue une sauvegarde :
List 5 //la liste 5 du fichier 1 va dans la List Ans qui est universelle.
File2 //Je me mets sur le fichier 2
List Ans → List 1 //Je copie la List Ans dans la List 1 du fichier 2
File1 //Je reviens au fichier 1 pour continuer.
[…]
//Lorsque je quitte le jeu :
ClrList //J'efface tout le fichier 1
Stop

//Quand je reprends la partie :
File 2
"S" → List 1[0]
If Not List 1[1 : Then
"Aucune sauvegarde disponible."◢
Stop
IfEnd
List 1
File 1
List Ans → List 5

Une autre application : Un Super Drawstat.
[...]
D = 2 ⇒ {.1,5.03,2.08,10.08,12.15 → List 6 //Ceci est un premier sprite à afficher pour un combat : le monstre.
[…]
{4.04, 5.04, 6.03, 15.03, 16.04, 17.04, 17.14, 12.19, 9.19, 4.14, 4.04 → List 4 //Un deuxième sprite, le joueur.
//Puis on dessine.
Augment(15+List 4, 80+List 6) // J'assemble les deux listes en modifiant leurs valeurs
1 → Tθmin
Dim List Ans → Tθmax
Graph(X,Y)=(Int List Ans[T], 100 Frac List Ans[T

Il existe également un tutoriel pour réaliser des effets de particules, réalisé par Ninestars. Il est assez complexe et fait appel à une utilisation assez poussée des listes. Si vous avez suivi ce tutoriel jusqu'au bout, il ne devrait pas y avoir de problème ! Le lien se trouve ici.

Liens utiles
Le précédent TDM : Créez de magnifiques écrans-titre pour vos jeux !
Le Jeu du Mois : le retour ! N'oubliez pas de voter !
Savoir manipuler le Super Drawstat, une méthode de dessin puissante !
Mettez vos nouvelles connaissances à l'usage avec ce tutoriel sur les effets de particules .
Si vous connaissez mal les fonctions utilisées : Seq(, List, File, Augment(, ClrList, Frac.


Discutez de ce tutoriel sur le forum >> Voir le sujet dédié (27 commentaires)

Planète Casio v4.3 © créé par Neuronix et Muelsaco 2004 - 2024 | Il y a 35 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd