CODINGApprendre pas à pas la programmation en assembleur Z80 ★ Scrollings en folie! ★

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

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é :)

★ ANNÉE: 2025
★ AUTEUR: Roudoudou

Je participe au site:

» Vous avez remarqué une erreur dans ce texte ?
» Aidez-nous à améliorer cette page : en nous contactant via le forum ou par email.

CPCrulez[Content Management System] v8.732-desktop/c
Page créée en 654 millisecondes et consultée 5 fois

L'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent  du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko.