Revenir au plan du site

Utiliser une carte de tuiles (ou Atlas ou TileMap) pour gagner de la mémoire


Dans l'exemple de [scrolling horizontal] j'ai utilisé une (très) grosse image sur laquelle je rebouclais. Il est difficile de faire un jeu entier et conséquent de cette manière. Déjà, il faudra trouver un graphiste assez fou pour poser autant de pixels. Ensuite, vous allez vite vous retrouver limité par le stockage ou la mémoire.

L'idée est de factoriser vos graphismes en constituant le décor global de petits éléments réutilisables, par exemple ci-dessous, le plus évident jeu de tuiles carrées pour construire n'importe quel type de route.
Mais il n'y a aucune limitation dans la forme des tiles, on peut utiliser des tiles en relief pour les utiliser en 3D isométrique ou même hexagonales!


Ainsi, une fois les graphismes définis, par exemple avec des sprites mode 0 de 8x16, on peut définir un écran de 128x256 en 256 octets au lieu de 16384 octets en pur bitmap.

En attribuant (par exemple) 16k pour les tuiles et 16k pour la map, on aurait un jeu totalisant 64 écrans (c'est un peu moins que le nombre d'écrans du jeu Rick Dangerous). Bien entendu, vous êtes libre de faire pencher la balance d'un côté ou de l'autre, il n'y a aucune répartition idéale, tout dépend de votre projet. Moins d'écrans avec plus de graphismes (32 écrans et 24K de graphs sur l'hypothèse de départ) ou bien plus d'écrans avec des graphismes plus simples et redondants (96 écrans et 8K de graphs).

Dans votre routine d'affichage, au lieu de directement lire le graphisme, on lirait la table, qui donnerait un numéro de sprite à aller chercher, et on afficherait chaque sprite à la queue leu-leu.

En organisant nos tuiles d'une certaine façon, ou en utilisant une table de correspondance pour les tuiles, on peut aussi indiquer à un moteur de jeu si la tuile est franchissable, si on peut monter dessus, si c'est un objet à récupérer, une porte, etc.

L'exemple le plus simple d'utilisation de tileMap se fait "à l'écran", sans scrolling, mais nous verrons dans l'article suivant que ça change peu de choses ;)
BUILDSNA : BANKSET 0
ORG #100 : RUN #100
ld sp,#100
ld ix,tileMap
ld de,#C000
ld yh,12 ; nombre de tuiles en hauteur (ça tombe pas pile dans notre exemple avec un écran de 200 lignes)
afficheLigne
ld yl,10 ; nombre de tuiles en largeur
push de ; sauvegarder l'adresse de début de ligne de l'écran
afficheTuile
push de ; sauvegarder l'adresse du début de la tuile à l'écran
ld h,(ix+0) : inc ix : ld l,0 : srl hl ; x256/2 c'est la taille de nos tuiles
ld bc,tuiles : add hl,bc ; on a l'adresse de la tile
ld a,16
afficheLigneTuile
push de : ldi 8 : pop de
ld bc,#800 : ex hl,de : add hl,bc : jr nc,.novf : ld bc,80-#4000 : add hl,bc : .novf ex hl,de
dec a : jr nz,afficheLigneTuile
pop hl : ld bc,8 : add hl,bc : ex hl,de ; se placer juste à côté de la tuile précédente
dec yl : jr nz,afficheTuile
pop hl : ld bc,160 : add hl,bc : ex hl,de ; se placer sous les tuiles à gauche
dec yh : jr nz,afficheLigne
jr $

tileMap
defb 0,0,1,0,0,0,1,1,0,0
defb 0,1,0,1,0,1,0,0,0,0
defb 0,1,1,1,0,0,1,0,0,0
defb 0,1,0,1,0,0,0,1,0,0
defb 0,1,0,1,0,1,1,0,0,0
defb 0,0,0,0,0,0,0,0,0,0
defb 0,0,1,0,0,0,1,0,0,0
defb 0,0,1,1,0,1,1,0,0,0
defb 0,0,1,0,1,0,1,0,0,0
defb 0,0,1,0,0,0,1,0,0,0
defb 0,0,1,0,0,0,1,0,0,0
defb 0,0,0,0,0,0,0,0,0,0

tuiles
; deux tuiles unicolores arbitraires
tuile0 defs 8*16,%11110000
tuile1 defs 8*16,%00001111

Et voilà, notre écran contenant 120 tuiles à partir d'un atlas de deux tuiles est affiché :)