ALGO_TUTO 1: Récupérer les Coordonnées d'un tile dans une image.

Récupérer les Coordonnées d'un tile dans une image.

Il est utile en programmation de "simuler" le mode tiles des consoles. Le St fonctionne en mode bitmap. Les graphismes sont chargés directement d'une image dans la mémoire. Mais pour afficher un tile, on ne peut pas compter directement sur le numéro de positionnement du tile dans l'image.

Voici un petit algo pour retrouver la colonne (x) et la ligne (y) d'où se trouve le tile dans l'image.

Nous allons prendre pour exemple d'une image de 320 px de largeur et un tile de 16x16px.

On calcule en premier lieu le nombre de tile possible en largeur. Pour cela on fait tout simplement la dimension de l'image divisé par la taille du tile.
Dans notre exemple un petit 320/16 ce qui donne 20 tiles possibles par ligne.

A partir de là on peut calculer la position du tile voulu dans l'image.
Le numéro du tile à afficher sera "index%"
On va commencer par calculer sa ligne !
Pour cela rien de plus simple on divise index% par le nombre de tile possible sur une ligne donc 20 dans notre exemple.

(En GFA basic on va utiliser l'anti-slash pour la division. Cela permet de virer les virgules.)

ligne%=index%\20

Maintenant il faut calculer la colonne du tile. L'idée de base est de faire comme si que le tile est sur la premier ligne ! Tile 0 = colonne 0. Tile 5 = Colonne 5...

Pour cela on va tous simplement soustraire à notre index%, les lignes ou cet index se trouve.

Exemple : J'ai un index qui est égale à 44.
Sans faire de calcule magique nous savons qu'il va se trouver sur la colonne 4. (Attention on part à la colonne 0 les enfants)

Au niveau de la ligne, nous somme sur la ligne 2.  (44/20 = 2,2 mais on garde seulement la valeur sans les décimales. Donc 2.)

On va donc faire une ligne (2) * le nombre de tile possible par colonne. (20)
Ce qui fait 40 dans notre exemple.
Et les retrancher à notre index. (44) donc 44-20 = 4.

Notre index d'exemple se trouve donc en Colonne 4 et ligne 2.

En GFA cela donne :

colonne%=(index%-(ligne%*20))

Un petit :
print "Ligne:";ligne%;
print "Colonne:";colonne%

ET le tour est joués.

Pour connaitre la position X et Y pour utiliser RC_COPY ou le Blitter c'est simple on multiplie la ligne% et la colonne% par la taille du tile.

Pour notre exemple de l'index 44 :
X = 4 * 16
Y = 2 * 16

Notre tiles se trouve à la position 64/32 de l'image.

Exemple d'une procédure.

Code:

PROCEDURE  calcule_tile(index%)
  ligne%=index%\20
  colonne%=(index%-(ligne%*20))
Return

Si je ne me trompe, les variable !, |, &, % n'ont pas besoin d'un INT elles ne tiennent pas compte des chiffres après une virgule.

Shadow272 a écrit:Si je ne me trompe, les variable !, |, &, % n'ont pas besoin d'un INT elles ne tiennent pas compte des chiffres après une virgule.

Tu as raison shadow, lesdites variables sont des entiers mais le calcul de la division sera fait avec virgule puis converti en entier par le GFA, alors que INT évite cette étape.

Hmm, pas envie de bosser

Code:


' **** ton code
@calcule_tile(44)
'
@affiche_tile(x.tile&,y.tile&,x.dest&,y.dest&)
'
'
PROCEDURE calcule_tile(index&)    ! index& car si tes tiles sont dans un PI1, l'index ne sera jamais plus grand qu'un mot
'
  y.tile&=SHL&(INT(index&/20),4)       ! rotation de bits de 4 sur la gauche = *16
  x.tile&=SHL&( index& MOD 20,4)
'
RETURN
'
'
PROCEDURE affiche_tile(xs&,ys&,xd&,yd&)
'
  RC_COPY tilemap%,xs&,ys&,16,16 TO ecran%,xd&,yd&
'
RETURN


Si tu dois (ré) afficher beaucoup de tiles, il sera plus rapide d'avoir un tableau contenant le résultat de chaque calcul , encore une fois si tes tiles tiennent sur un pi1, il faut un tableau de 20 ce qui ne prend pas beaucoup de RAM mais te fera vraiment gagner en vitesse !!!

Merci pour cet exemple optimisé

Pas pour la ramener mais j'ai fais un petit test avec INT et sans INT et variables %.
Sur 2 boucles de 1000 contrôlées avec TIMER (1/200 sec)

CLS
'
d1%=155
d2%=77
t%=TIMER
'
FOR i%=1 TO 1000
d3%=INT(d1%/d2%)
NEXT i%
t2%=TIMER-t%
'
PRINT AT(10,5);t2%
'
d1%=155
d2%=77
t%=TIMER
'
FOR i%=1 TO 1000
d3%=d1%/d2%
NEXT i%
t3%=TIMER-t%
'
PRINT AT(10,9);t3%
'
~INP(2)


Non compilé
Avec INT : 66
Sans INT : 59

Compilé
Avec INT : 42
Sans INT : 10

Oula un simple tuto 'pense bête pour moi en plus xd ' et 36 pages de test
Merci pour la "correction".

Bisous.

Shadow272 a écrit:Pas pour la ramener mais j'ai fais un petit test avec INT et sans INT et variables %.
Sur 2 boucles de 1000 contrôlées avec TIMER (1/200 sec)

Non compilé
Avec INT : 66
Sans INT : 59

Compilé
Avec INT : 42
Sans INT : 10

Hmm, t'es sûr que tu veux pas la ramener un peu ? T'as raison quand même ! Moi je la ramènerai grave à ta place

Bref, ça semble sans appel, du coup je me demande d'où je tenais cette idée, sûrement d'un temps où je codais plus de bugs que trucs qui fonctionnaient, et j'avais du trouver que ça résolvait mon problème ...
Pfiou ! Mais du coup ça va être chaud de perdre l'habitude, j'en met à toutes les sauces des INT moi depuis !!!

Merci shadow d'avoir pris le temps de tester

Avec plaisir mon ami Tomchi.
Si je peux encore être util . . .