[Tutoriel] Le Super DrawStat
Posté le 08/09/2013 19:36
Vous connaissez le DrawStat, et bien voici le Super DrawStat !
Pour ceux qui ne connaissent pas le DrawStat
Cliquer pour enrouler
Ce tutoriel décrit une méthode permettant dessiner des traits à l'écran. On renseigne dans deux List les coordonnées sur x et sur y de plusieurs points, puis on relie tout ces points entre eux pour faire une image
Le Super DrawStat se comporte de la même façon que le DrawStat normal, cependant la vitesse à laquelle il dessine est bien plus rapide, environ 20% à 40% pour un tracé identique. Et encore plus rapide que les F-line. Voici comment l'utiliser :
Initialisation :
Le Super DrawStat s'initialise en même temps que le ViewWindow, il suffit de rajouter à la suite les trois composantes d'initialisation.
Le paramétrage classique est ViewWindow 1,127,0,1,63,0 Il suffit de rajouter à la suite : ,
MIN,
MAX,
PAS
MIN correspondant à la valeur de départ (1 en général)
MAX la dernière valeur (la taille des List en général)
PAS la valeur dont T (Voir plus bas) augmente à chaque fois, (1 en général)
Pour choisir le dessin à tracer, il suffit de rentrer dans deux List les coordonnées x et y du dessin.
Utilisation :
Il faut utiliser la commande.
Graph(X,Y)=(
Graph(X,Y) est une commande trouvable à l'adresse : SHIFT F4 F5 F3
cette fonction prend deux arguments : la première List correspondant aux x, et la seconde List correspondant aux y.
Voici ce que cela donne au complet
Graph(X,Y)=(List 1[T],List 2[T])
Il est obligatoire de mettre [T], et uniquement T sinon cela ne fonctionnera pas. La variable T est la variable qui va permettre de "lire" le dessin.
Elle commence avec la valeur MIN définie par le ViewWindow, et augmente de PAS jusqu'a arriver à MAX. Il est donc important de bien paramétrer le ViewWindow avec des nombres entiers pour pas avoir une situation telle que List 1[3.7] si T prend la valeur 3.7, ce qui provoque une erreur.
Exemple :
Voici par exemple comment tracer un triangle formé par les points A(10;7), B(30;54) et C(18;29).
La List 1 enregistre les coordonnées des points sur l'axe x, et la List 2 sur l'axe y. Ensuite on trace un trait entre chaque points pour former le triangle. (Il y a 4 points pour refermer le triangle
)
ViewWindow 1,127,0,1,63,0,1,4,1
{10,30,18,10}->List 1
{7,54,29,7}->List 2
Graph(X,Y)=(List 1[T],List 2[T])
Astuces :
Voilà, maintenant vous avez les bases pour pouvoir utilisez le SuperDrawStat, mais son véritable atout réside dans sa flexibilité et sa liberté d'utilisation. Voici quelques astuces très utiles pour exploiter au maximum cette fonction.
Utilisez Tomin, Tomax et Toptch (VARS F1 F3) pour lire et modifier les paramètres d'initialisation MIN, MAX et PAS
MAX doit être inférieur ou égale à la taille des List.
En jouant sur ces paramètres on peut donc dessiner que les 3 premiers traits du dessins, un traits sur deux, que les derniers, ...
Attention, modifier ces paramètres modifient le ViewWindow, c'est à dire qu'au prochain dessin, l'écran sera effacé.
Il est aussi possible de dessinez avec un style de trait différent :
-traits continus : G-Connect(SHIFT MENU F6 F3)
-des points : G-Plot (SHIFT MENU F6 F3)
-traits simples : S-L-Normal (SHIFT MENU F6 F2)
-traits épais : S-L-Thick (SHIFT MENU F6 F2)
-pointillets épais : S-L-Broken (SHIFT MENU F6 F2)
-pointillets : S-L-Dot (SHIFT MENU F6 F2)
Il est possible d'utilisez des équations à la place des List :
Graph(X,Y)=(List 1[T],4)
Graph(X,Y)=(17xList 1[4T],List 2[T]+4)
Graph(X,Y)=(15+T,List 1[T])
...
(La variable qui évolue c'est T, pas X)
Ainsi on peut éviter de créer des List simple comme par exemple {0,1,2,3,...} en remplacant par T qui va prendre successivement ces valeurs (tout dépend du paramétrage bien entendu).
Vous pouvez facilement effectuer un décalage pour afficher vos images.
Par exemple imaginons que vous avez enregistré l'image d'un personnage, dans les List 1 et List 2
En DrawStat
Cliquer pour enrouler
Pour l'afficher aux coordonnées I et J vous deviez faire en DrawStat
{...}->List 1
{...}->List 2
S-Gph1 DrawOn,xyline,List 3,List 4,1,Dot
...
I+List 1->List 3
J+List 2->List 4
DrawStat
On est obligé d'utiliser des List 3 et List 4 pour ne pas modifier les List 1 et List 2 qui enregistrent l'image.
Tandis que en Super DrawStat, on peut s'en passer
{...}->List 1
{...}->List 2
Dim List 1->Tomax
Graph(X,Y)=(I+List 1[T],J+List 2[T])
Dim List 1 permet de récupérer la taille de la List 1. On n'utilise jamais les variables X et Y, elles sont modifiées par les fonctions graphiques donc le résultat ne sera pas ce à quoi vous vous attendiez
Il est également possible de ne pas relier deux points consécutifs dans les List. Par exemple si notre dessin est en plusieurs parties (imaginons un personnage et ses yeux).
L'astuce consiste à rajouter un point trop éloigné pour que la calculette ne le dessine pas et passe au suivant.
par exemple
{10,23,7,e9,12,3}-List 1
{34,30,7,e9,2,3}-List 2
e9 est une façon courte d'écrire 1000000000
Encore plus de vitesse ? Dessiner à la chaîne !
Il arrive que dans certains jeux, il faille dessiner beaucoup d'images à la suite.
Je vais prendre l'exemple d'une carte que l'on veut dessiner en utilisant le principe des
Tiles, ou tuiles en français (entre autres pokemon), on pense naturelement à parcourir dans une boucle toutes les cellules de notre Mat, List, ... qui enregistre notre carte, et afficher les images les unes après les autres.
Cette méthode est simple, mais on voit l'image se construire au fur et à mesure. Le rendu n'est pas terrible et donne une impression de lenteur.
Pour résoudre ce problème, on va charger toutes les images dans une même List, puis tout afficher d'un coup !
Je vous présente la fonction Augment( OPTN F1 F6 F5
Cette fonction permet de mettre bout à bout deux List pour n'en former qu'une
{1,2,3}->List 1
{4,5,6}->List 2
Augment(List 1, List 2)->List 3
List 3 = {1,2,3,4,5,6}
Ainsi votre code pour afficher votre carte aura cette structure :
{e9}->List 1
{e9}->List 2
// boucle
// on récupère dans List 3 et List 4 l'image de tile
Augment(List 1, List 3)->List 1
Augment(List 2, List 4)->List 2
// fin de boucle
Dim List 1->Tomax
GraphXY(List 1[T], List 2[T])
On voit que GrapXY n'est utilisé qu'à la fin, avec les List 1 et 2 remplies, donc la carte est tracé en une fois beaucoup plus rapidement.
Pourquoi List 1 et 2 sont initialisées avec e9 ? Simplement que l'on ne peut pas initialiser des List vides, pour utiliser Augment, il faut au moins un élément dans chaque List.
Il reste une dernière précaution, ajouter e9 à la fin de chaque image, sinon elles seront toutes reliées, évidemment
Pour donner un ordre d'idées, le
gain de vitesse est de 10% pour dessiner des images d'une vingtaine de points et
35% pour dessiner des images avec peu de points. Le système est plus rentable, si le nombre de point par image et faible.
L'inconvénient c'est qu'il y a un temps d'attente, mais placer un Text 1,1,"Chargement" fait tellement pro
mais aussi que cette technique est gourmande en mémoire.
Exemple de jeux utilisant cette méthode :
Block Tower,
A vers B
Economisez les indices de List :
Deux List pour chaque image est assez gourmand en indice, même si il y en a 26 par fichier. Une autre astuce permet d'enregistrer dans une seule List à la fois les coordonnées sur x et sur y d'une image. Pour cela on va utiliser les complexes.
ViewWindow 1,127,0,1,63,0,1,4,1
{10,30,18,10}+i{7,54,29,7}->List 1
Graph(X,Y)=(ReP List 1[T],ImP List 1[T])
On renseigne dans une première accolade les coordonnées x, ensuite on rajoute le
i (SHIFT 0) puis on renseigne dans une deuxième accolade les coordonnées sur y. Rep et Imp permettent de séparer la partie sur x et la partie sur y (OPTN F3 F6). On remarquera que dans l'initialisation du ViewWindow, MAX est toujours égale à 4. La taille de List 1 est toujours 4 et pas 8. Attention, cette astuce ne permet pas de gagner de la mémoire : le poids en octet d'une telle List est multiplier par deux, ce qui pèse autant que deux List.
Performances :
J'ai fait des tests pour comparer les performances :
dessiner 128 traits une fois :
-DrawStat : 1,4 s
-Super DrawStat : 0,9 s
dessiner 3 traits 100 fois :
-DrawStat : 22,4 s
-Super DrawStat : 18,9 s
On voit clairement que le Super DrawStat est plus rapide, en fait le DrawStat affiche les points puis trace les traits alors que le Super DrawStat dessine directement les traits.
Inconvénients :
Il existe deux incovénients, d'une part cela utilise la variable T, qui devient donc inutilisable dans le programme.
D'autre part, il n'est pas possible de dessiner des petits carrés ou des croix comme en DrawStat.
Voilà, si découvrez d'autres astuces n'hésitez pas à les partager, il est en existe énormément
Regardez aussi le tutoriel sur le Multi DrawStat, pas forcement plus rapide, mais qui permet d'autres choses.
Citer : Posté le 02/07/2016 12:11 | #
Ah oui, de ce point de vue, effectivement. C'est un peu comme "nos ancêtres les Gaulois", finalement.
Citer : Posté le 27/09/2016 19:57 | #
Petite mise à jour du tutoriel. J'ai réduit les références au DrawStat. Plus grand monde ne commence par ça, il n'est même plus dans les tutoriels épinglés je crois. J'ai aussi rajoutée une partie sur les complexes et quelques modifications un peu partout.
Citer : Posté le 27/09/2016 21:16 | #
Concernant la partie sur les complexes,
il existe une technique qui permet d'économiser à la fois des indices et de la mémoire, que je compte utiliser dans mon propre programme. Cette astuce m'a été évoquée par Suruq Game :
Plutôt que d'écrire x+iy, on écrit x.y. Je m'explique :
Par exemple : on veut un point de coordonnées (20 ; 17), donc au lieu de rentrer 20+17i dans une case de la liste, on rentre 20.17 ! Cela prend donc 12 octets au lieu de 24 !
Astuces : si x vaut 0, on peut écrire directement ".17". De même, si y vaut un multiple de 10 (prenons 30 par exemple), on peut simplement écrire "20.3". Après, tout se joue dans le Graph(X,Y).
Citer : Posté le 27/09/2016 21:23 | #
Effectivement c'est une très bonne idée, mais les astuces dans ce genre se développent au cas par cas. Par exemple de cette manière, tu ne peux pas stocker des nombres à virgule, la virgule servant déjà à séparer les x des y... Et en plus de ça il faut définir un nombre de chiffres constant pour les y (je pas trop envie de rentrer dans les détails)
Ici je reste généraliste pour que tout puisse fonctionner. Si la personne cherche à optimiser, il le fait par lui-même
Citer : Posté le 27/09/2016 21:33 | #
ah, oui, mais de manière très générale on travaille sur une fenêtre de 128*64 pixels, donc en l’occurrence... mais c'est vrai que je vais plutôt garder l'idée bien égoïstement, plutôt.
Citer : Posté le 29/09/2016 20:13 | #
Je n'ai pas l'impression que cette solution soit réellement meilleure... regardons ce qui se passe si tu transformes une liste « 1D » en une liste « 2D » avec ta méthode :
Observons ce qui se passe avec les complexes :
Conclusion : il y a un caractère d'overhead pour chaque valeur dans chacune des méthodes ; pour des listes assez grandes le résultat est le même.
... oui, c'est vrai qu'il y a 12 octets gagnés... (le coup du comportement asymptotique reste intéressant !)
Citer : Posté le 29/09/2016 20:52 | #
Ce que tu cites, aussi, correspond à du hardcode, il se peut que le "programmeur" choisisse d'enregistrer ces valeurs a priori. M'enfin, c'est moins commun. Après, avec les astuces bonus que j'ai donné, cette technique gagne en rentabilité.
Citer : Posté le 30/01/2018 22:27 | #
Je n'arrive pas à utiliser un style de trait différent avec la commande Graph(X,Y), Quelqu'un peut m'aider?
Citer : Posté le 30/01/2018 22:42 | #
Tu doit mettre le style juste avant Graph(X,Y) su la même ligne
Par exemple :
SketchThick Graph(X,Y)(list1[T], list 2[T]
Par contre épaissir le trait comme dans l’exemple ralenties fortement la vitesse d’affichage