Tutoriel et documentation - Wlib

- A rédiger -

- Linkakro 17/06/2014 - Copie du readme de matrefeytontias, correction de la forme pour le forum, et commentaires ajoutés en dessous.

######
Pour utiliser les fonctions de Wlib dans vos programmes Basic, mettez tous vos arguments dans la liste LWLIB, mettez le numéro de la fonction dans Ans puis
appelez prgmUSEWLIB. Exemple :

:{48,32}→LWLIB
:5:prgmUSEWLIB

Voici la liste des commandes actuellement disponibles :
___________________________________________________________________________________________________
Numéro de la commande| Arguments → LWLIB               | Effet
___________________________________________________________________________________________________
0 (shiftUpDown)      | { n° de la ligne de l'écran   | Scrolle l'écran en haut ou
                    | à afficher en haut }            | en bas (avec wrapping)
___________________________________________________________________________________________________
1 (shiftLeft)        | { nb de pixels à scroller }     | Scrolle le buffer à gauche
___________________________________________________________________________________________________
2 (shiftRight)       | { nb de pixels à scroller }     | Scrolle le buffer à droite
___________________________________________________________________________________________________
3 (checkPrgmExists)  | { n° Str contenant le nom }     | Stocke 1 dans W si le programme
                    |                                 |  existe, sinon stocke 0 dans W
___________________________________________________________________________________________________
4 (createPrgm)       | { n° Str contenant le nom     | Crée le programme au nom spécifié
                    | , taille }                      | avec la taille spécifié
                    |                                 | (écrase si existant)
___________________________________________________________________________________________________
5 (pixelOn)          | { X, Y }                        | Allume le pixel aux coordonnées
                    |                                 | (X,Y) sur le buffer
___________________________________________________________________________________________________
6 (pixelOff)         | { X, Y }                        | Éteint le pixel aux coordonnées
                    |                                 | (X,Y) sur le buffer
___________________________________________________________________________________________________
7 (pixelChange)      | { X, Y }                        | Change l'état du pixel aux
                    |                                 |  coordonnées(X,Y) sur le buffer
___________________________________________________________________________________________________
8 (loadSprite)       | { n° Str contenant les sprites, | Charge des sprites 8*8 codés en
                    | nb de sprites à charger }       |  hexa dans les slots de Wlib
                    |                                 | à partir du 0
___________________________________________________________________________________________________
9 (loadTilemap)      | { n° Str contenant la tilemap,  | Charge une tilemap de la largeur
                    | largeur, hauteur }              |  et hauteur données
___________________________________________________________________________________________________
10 (drawSprite)      | { X, Y, n° slot }               | Affiche un sprite 8*8 aux
                    |                                 |  coordonnées (X,Y) sur le buffer
___________________________________________________________________________________________________
11 (drawTilemap)     | { X, Y }                        | Affiche la tilemap chargée
                    |                                 | en partant de la tile (X,Y),
                    |                                 | permettant ainsi du
                    |                                 | scrolling en faisant varier (X,Y)
___________________________________________________________________________________________________
12 (fastCopy)        | aucun                           | Affiche le buffer à l'écran
___________________________________________________________________________________________________
13 (fastCopyErase)   | aucun                           | Affiche le buffer à l'écran
                    |                                 | puis efface le buffer.
                    |                                 | Moins d'une µs de différence
                    |                                 | avec la version n'effaçant pas.
___________________________________________________________________________________________________
14 (invBuffer)       | aucun                         | Inverse tous les pixels du buffer
___________________________________________________________________________________________________

Pensez à afficher le tampon (buffer) à l'écran, avec fastCopy ou fastCopyErase) pour toutes les fonctions de dessin qui ne provoquent pas un affichage immédiat.

Les coordonnées et numéros de lignes et colonnes sont des indices de pixels commençant à 0.
Les indices des slots de sprites sont de 0 à N-1, pour N slots.

Les tuiles (des sprites 8*8, "tiles" en anglais) portent les indices 0 à 9 puis A à Z pour être utilisés par la map.
La map organise les tuiles de gauche à droite puis haut en bas (écriture latine).
Chaque tuile organise ses quartets (nibbles) en ordre latin. (groupes horizontaux de quatre pixels)
Chaque quartet (nibble) organise son LSB (bit de poids faible) à droite et son MSB (poids fort) à gauche.

Code:

Ordre dans une tuile
32107654
BA98FEDC
ainsi de suite

Bon courage pour la rédaction ;-)

T'inquiète, ce sera pas mon premier

Bonjour,
si je comprends bien il va y avoir une documentation sur Wlib ?

Bienvenue sur Tout-82 ;-)

Oui, en effet, c'est prévu.

Houlà oui, zut, j'ai complêtement oublié ça :/

Euh, oui, il y en aura une, mais pas dans les semaines à venir, je n'ai pas beaucoup de temps en ce moment.

(Sauf si un volontaire veut s'y coller bien sur)

Ok, pas de soucis!

Persou??? Ça donne quoi?

Pfff, faut tout faire ici.

Ben tu n'as pas encore tout finis

C'est que je veux comprendre les fonctions en détail car ca marche pas sur émulateur PC...

Comment ça ça marche pas?
Le code exemple marche bien sur ému, et j'ai testé un peu la lib sur calto ça fonctionne aussi

Tu as regardé le readme?

Par contre... c'est trop lent de gérer les chaines, j'espère que la fonction que matref a prévu pour agir sur la tileMap sera plus efficace x)

L'organisation des pixels est discutée avec mes commentaires de l'annonce et mes programmes Basic de conception de sprites pour Wlib. Je ne pense pas que le reste nécessite plus que le readme.
Je copie le readme et complète pour remplir le premier message du sujet.

Je sais pas trop pourquoi... Est ce que c'est la version 8xp qui bugge sur 84+ 2.55 MP??

J'émule dans Wabbitemu 84plus 2.43 et 2.55mp.
J'envoie A.8xp+WLIB.8xp+USEWLIB.8xp puis exécute A.8xp.
J'émule dans Wabbitemu 83 rom1.10.
J'envoie A.8xp+WLIB.83p+USEWLIB.83p puis exécute A.8xp.
Tout fonctionne.
Par contre le transfert d'un 8xp dans VirtualTI de 83 plante toujours donc pas de test immédiat.

Par contre juste :
0 (shiftUpDown) | { n° de la colonne de l'écran à afficher en haut }->WLIB

Ca ne serait pas plutôt n° de la ligne ?

à ce sujet
0 (shiftUpDown)      | { n° de la colonne de l'écran   | Scrolle l'écran en haut ou
                   | à afficher en haut }            | en bas (avec wrapping)
je n'ai pas bien compris comment on choisissait le sens ...

Oui le lisezmoi mentionne colonne au lieu de ligne.
Je teste : la valeur absolue du paramètre est le décalage vers le bas de l'écran en nombre de pixels : il n'y a pas de sens, il faut se débrouiller en connaissant le décalage précédent.

En fait, seul l'affichage change.
En gros, lorsque vous demandez à l'écran d'afficher un pixel à une position Y vers le bas en partant du haut de l'écran, il va rajouter la valeur du décalage (puis faire un petit modulo pour se retrouver dans l'écran).
Ce n'est pas vraiment ça mais en gros ça peut être pris comme ça. Donc du coup, les décalages ne s'ajoutent pas : ils se remplacent.

C'est comme si l'écran était coupé en 2, et que la partie du haut se retrouve en bas.

Ce n'est pas du tout la même chose pour le droite/gauche, dans ce cas il s'agit d'un véritable scrolling de juste ce qui est affiché, sans conséquence pour les affichages futures.

Oui oui, un wrapping de l'affichage. Le repère en octets est juste décalé. Et oui le scroll latéral de matrefeytontias ne se base pas sur le repère du système, mais modifie chaque octet de l'image présente pour en déplacer le contenu.

Faut que je mette à jour Wlib, j'ai des fonctions de fichiers qui marchent.

merci pour les précisions apportées sur le point évoqué.

j'essaie de faire fonctionner Wlib mais ce n'est pas évident. où y a t il une doc avec des exemples ? notamment sur les sprites
Ce que j'ai cru comprendre et qui est un peu flou
on fait une chaine
"0123456789ABCDEF00FF00FF00FF00FF" -->Chaine1  //2 x 16 donc 2 sprites ?

on charge les sprites sur des emplacements mémoires ?
{1,2} -->Lwlib  // (1 = 1er slot et 2 = le nombre de Sprites ? )
8:prgmUSEWLIB // pour mémoriser

{2,X,Y} -->Lwlib // 2 = 2eme sprite ? X,Y en pixels ?
10:prgmUSEWLIB // pour dessiner dans le buffer

13:prgmUSEWLIB // copy le buffer sur l'écran et efface le buffer ?

j'ai fait quelques essais et je ne comprends pas toujours ...

merci de votre aide

Tout ce que tu as dit là est vrai, et ton programme devrait marcher. Sache juste que je ne fais pas (encore) de détection pour savoir si un sprite est affiché hors de l'écran, donc attention à ça (surtout en haut et en bas).

Oups j'ai bien étudié alors...
il y a une fonction pour effacer le buffer uniquement ?

J'en aurai bien mis une, mais c'est tellement lent.

Attends... Lent d'effacer un buffer?
Le temps d'appeler la fonction sera plus lent que celui de l'effacement à proprement parler non?

Par contre j'ai eut une idée: ça serait possible d'éxécuter une liste de fonctions de WLib plutôt qu'une seule fonction?
Du genre on stocke dans LWLIB les arguments de toutes les fonctions qu'on veut exécuter dans l'ordre, puis dans Ans on met le numéro des fonctions dans l'ordre qu'on veut.

Comme ça ça limiterai les appels à WLIB, et ça accélérerait le tout...
Faisable?

Bien sûr que c'est rapide d'effacer un buffer et que c'est l'appel de fonction qui est lent -_-

Oui j'ai pensé faire ça, mais comment saurais-tu combien d'arguments passer du coup ?
Une solution serait de tout stocker sous la forme {nb arguments, arguments, ..., n° fonction} et de répéter. Vu que je me débrouille pour n'utiliser que des nombres comme arguments ça devrait passer.

Enfin le plus utile c'est de mettre les sprite-collisions ça c'est facile et pis ça aide pas mal...

Bonjour,

matrefeytontias a écrit:Tout ce que tu as dit là est vrai, et ton programme devrait marcher. Sache juste que je ne fais pas (encore) de détection pour savoir si un sprite est affiché hors de l'écran, donc attention à ça (surtout en haut et en bas).

et ça il n'affiche rien .. je ne comprend pas de trop..

rpgcreator a écrit:Enfin le plus utile c'est de mettre les sprite-collisions ça c'est facile et pis ça aide pas mal...

c'est à dire ?
quand on connait un concept c'est toujours facile,
as-tu un exemple car je ne sais même pas de ce dont il s'agit...
merci

Les numéros de slot commencent à 0, pas à 1

Code:

{1,2} -->Lwlib  // (1 = [strike]1er slot[/strike] indique la chaine dans laquelle sont rangés les sprites, donc Str1, et 2 = le nombre de Sprites )
8:prgmUSEWLIB // pour charger

{2,X,Y} -->Lwlib // [strike]2 = 2eme sprite ?[/strike] Non, 2 = 3e slot... Donc ça va pas, faut commencer à 0, donc 2e sprite = 1. X,Y en pixels ?
10:prgmUSEWLIB // pour dessiner dans le buffer

Sur ta capture:
{0,X,Y->WLIB
10:prgmUSEWLIB
Pour afficher le sprite sur le buffer, à la position (X; Y).

Oui j'ai pensé faire ça, mais comment saurais-tu combien d'arguments passer du coup ?

Mais toutes les fonctions n'attendent qu'un nombre fixe d'arguments non?

Du coup par exemple on pourrait faire:

Code:

"0123456789ABCDEF00FF00FF00FF00FF->Chaine1
{1,2,1,X,Y->WLIB
{8,10,13:prgmUSEWLIB

On sait que la fonction 8 attend 2 arguments, ce sont les 2 premiers dans LWLIB. Ensuite la fonction 10 en attends 3, ce sont les 3 suivants. Pour finir, la n°13 n'en attends pas.

Enfin le plus utile c'est de mettre les sprite-collisions ça c'est facile et pis ça aide pas mal...

J'avoue que je ne suis pas sur de ce dont tu parles