Revenir au plan du site

Placer des sprites sur son scrolling

Si vous n'avez pas lu la série sur le clipping de sprites, et en particulier [ le cas de l'exclusion ], le code suivant va vous paraitre obscur.

En effet, le code d'exclusion d'affichage est strictement identique (aux coordonnées de résolution près) à celui d'un sprite logiciel. On va simplement comparer des X en coordonnées mode 2, plutôt qu'en octets. Pour les lignes, rien ne change et enfin, on n'appellera pas notre routine de sprite soft, on va juste écrire les coordonnées et le zoom, ou désactiver nos sprites hard.

Pour illustrer ce que l'on va pouvoir faire, prenons une map d'exemple. Au hasard, un circuit de voitures construit avec quelques tiles récupérées depuis le jeu [ Carlos Sainz ]
 

Cette map dans son [ fichier d'origine ] a une résolution de 1024 pixels (mode 0) sur 2048 lignes.

Dans le sens de la hauteur, les calculs vont être assez simples à réaliser car le positionnement des sprites hard en hauteur se fait à la ligne. On traitera avec des lignes.

Par contre, dans le sens de la largeur, le positionnement d'un sprite hard en X bénéficie de la précision du mode 2, soit 1/4 de pixel mode 0.

Cela veut dire que si on veut afficher un sprite sur la position X du 200è pixel de l'arrière-plan, la coordonnée X absolu de notre sprite est de 800. Et rapport à la taille de notre map, la coordonnée X maximale va être de 1024 x 4 = 4096 pixels mode 2. Si on voulait simplifier, on pourrait choisir de positionner notre véhicule (mince j'ai spoilé!) sur une coordonnée mode 0 et multiplier à la fin des comparaisons. Mais visuellement ça risque d'être gênant alors on va la jouer "fine"!

Pour commencer, je propose d'ajouter deux variables en relation avec notre scrolling et qui vont correspondre aux coordonnées "façon sprite hard" du coin supérieur gauche de l'écran.

scroll_corner_posx defw 0 scroll_corner_posy defw 0

Grâce à ces coordonnées écran, on va pouvoir compenser les coordonnées des sprites hard (une simple soustraction des coordonnées écran aux coordonnées du sprite).

Lors du scrolling, il faudra modifier ces coordonnées (mais PAS lors de la compensation qui ne fait que rattraper le scrolling de l'écran précédent). On se positionne dans le code à côté des modifications de depx et depy. On ne doit pas mettre à jour si le Scroll n'a pas pu se réaliser car on est en butée.

ld a,(OCTET_CURSEUR_BAS) : and BIT_CURSEUR_BAS : jr nz,.noBas call ScrollBas : jr z,.noBas : ld hl,depy : dec (hl) : ld hl,(scroll_corner_posy) : inc l : inc hl : ld (scroll_corner_posy),hl : .noBas ld a,(OCTET_CURSEUR_HAUT) : and BIT_CURSEUR_HAUT : jr nz,.noHaut call ScrollHaut : jr z,.noHaut : ld hl,depy : inc (hl) : ld hl,(scroll_corner_posy) : dec hl : dec l : ld (scroll_corner_posy),hl : .noHaut ld a,(OCTET_CURSEUR_DROITE) : and BIT_CURSEUR_DROITE : jr nz,.noDroite call ScrollDroite : jr z,.noDroite : ld hl,depx : inc (hl) : ld hl,(scroll_corner_posx) : ld bc,-4 : add hl,bc : ld (scroll_corner_posx),hl : .noDroite ld a,(OCTET_CURSEUR_GAUCHE) : and BIT_CURSEUR_GAUCHE : jr nz,.noGauche call ScrollGauche : jr z,.noGauche : ld hl,depx : dec (hl) : ld hl,(scroll_corner_posx) : ld bc,4 : add hl,bc : ld (scroll_corner_posx),hl : .noGauche

La structure sprite évolue pour tenir compte des spécificités des sprites hard. On va remplacer le champ adresse pour y mettre deux choses :
- L'octet de poids fort de l'adresse des données dans l'ASIC
- L'octet de poids faible de l'adresse de configuration dans l'ASIC
Enfin, la largeur du sprite change de signification. Nous utiliserons la largeur comme un nombre de pixels mode 2.

struct sprite positionx defw positiony defw adresseDonnees defb adresseConfiguration defb sprlargeur defb sprhauteur defb endstruct

Pour rappel, notre véhicule est composé de 4 sprites assemblés logiciellement dans un carré de 2x2. Sa résolution mode 1 est de 32x32 pixels mais si on doit comparer sa taille sur un écran de résolution mode 2, sa résolution d'encombrement est de 64x32. Nous n'avons pas besoin de tester chaque sprite de façon indépendante car les coordonnées des sprites hard dans l'ASIC à notre niveau de zoom nous laissent une tolérance.
On initialisera simplement notre structure, seules les positions sont supposées changer avec le temps.

ld ix,tuture ld hl,300 : ld (ix+sprite.positionx),hl ld hl,200 : ld (ix+sprite.positiony),hl ld a,64 : ld (ix+sprite.sprLargeur),a ; en pixels mode 2 ld a,32 : ld (ix+sprite.sprHauteur),a ; en nombre de lignes ld a,#40 : ld (ix+sprite.adresseDonnees),a ; adresse #4000 pour les données ld a,0 : ld (ix+sprite.adresseConfiguration),a ; adresse #6000 la configuration

On fera donc un seul test pour les 4! Et on va adapter notre routine pour y claquer les dimensions d'un écran en mode 2. Il n'y aura plus d'appel à la routine de sprite mais on activera/désactivera le groupe de sprite selon qu'il soit intégralement clippé ou non. On utilisera les positions compensées pour le placer sur l'écran.

AfficherTableauSprite RMR2 ASICON ld iy,tableau_sprite .loop ld hl,(iy+sprite.positionx) : or a : ld de,(scroll_corner_posx) : sbc hl,de : ld (posx_compensee),hl bit 7,h : jr nz,.testGauche ; si c'est négatif on fait le test de gauche ; on teste le débordement à droite (512 pixels mode 2 en largeur) ld de,LARGEUR_ECRAN_MODE_2 : or a : sbc hl,de jp m,.hautBas jp .horsEcran .testGauche ld a,(iy+sprite.sprlargeur) : add l : ld l,a : ld a,h : adc 0 jp m,.horsEcran ; négatif hors écran, reste à tester le zéro ld a,l : or a : jp z,.horsEcran ; on fait un raccourci de calcul car on partait d'une position négative ; quasiment le même code de tester le débordement en vertical .hautBas ld hl,(iy+sprite.positiony) : or a : ld de,(scroll_corner_posy) : sbc hl,de : ld (posy_compensee),hl bit 7,h : jr nz,.testHaut ; si c'est négatif on fait le test du haut ; on teste le débordement en bas de l'écran de 256 lignes ld de,HAUTEUR_ECRAN_LIGNE : or a : sbc hl,de jp m,.affiche jp .horsEcran .testHaut ld a,(iy+sprite.sprhauteur) : add l : ld l,a : ld a,h : adc 0 jp m,.horsEcran ; négatif hors écran, reste à tester le zéro ld a,l : or a : jp z,.horsEcran ; on fait un raccourci de calcul car on partait d'une position négative .affiche ; écriture peu optimisée des 4 sprites (X / Y / zoom) à cause de l'ordre des sprites, on verra plus tard ;) ld bc,#1234 : posx_compensee=$-2 ld de,#1234 : posy_compensee=$-2 ld h,#60 : ld l,(iy+sprite.adresseConfiguration) ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 : ld a,l : add 4 : ld l,a ; sprite 1 push bc : ld a,c : add 32 : ld c,a : ld a,b : adc 0 : ld b,a ; X+32 ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 : ld a,l : add 4 : ld l,a ; sprite 2 pop bc : ld a,e : add 16 : ld e,a : ld a,d : adc 0 : ld d,a ; Y+16 ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 : ld a,l : add 4 : ld l,a ; sprite 3 ld a,c : add 32 : ld c,a : ld a,b : adc 0 : ld b,a ; X+32 ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 ; sprite 4 jr .auSuivant .horsEcran ld h,#60 : ld l,4 : add (iy+sprite.adresseConfiguration) : ld bc,8 : xor a ; invisibiliser le sprite ld (hl),a : add hl,bc : ld (hl),a : add hl,bc : ld (hl),a : add hl,bc : ld (hl),a ; .auSuivant ld de,{sizeof}sprite : add iy,de ld a,(iy+sprite.sprlargeur) : or a ; tester la largeur du prochain sprite jp nz,.loop ; on reboucle si le prochaine sprite n'a pas une largeur nulle RMR2 ASICOFF ret

On peut partir sur un premier essai en positionnant un sprite hors écran visible et en allant le chercher avec le curseur, voir si il apparait, etc.

BUILDSNA : BANKSET 0 SNASET CPC_TYPE,4 ; modèle 6128+ conseillé ORG #100 : RUN #100 ;*** RMR2 tags + macro *** ASICOFF equ 0 : ROM0000 equ 0 : ROM4000 equ %01000 : ROM8000 equ %10000 : ASICON equ %11000 ROM0 equ 0 : ROM1 equ 1 : ROM2 equ 2 : ROM3 equ 3 : ROM4 equ 4 : ROM5 equ 5 : ROM6 equ 6 : ROM7 equ 7 macro RMR2 tags : ld a,{tags}+%10100000 : ld b,#7F : out (c),a : mend LARGEUR_MAP equ 128 : HAUTEUR_MAP equ 128 : LARGEUR_ECRAN_OCTET equ 64 : LARGEUR_ECRAN_MODE_2 equ 512 : HAUTEUR_ECRAN_LIGNE equ 256 OCTET_CURSEUR_HAUT   equ matriceClavier+0 : BIT_CURSEUR_HAUT   equ 1 : OCTET_CURSEUR_DROITE equ matriceClavier+0 : BIT_CURSEUR_DROITE equ 2 OCTET_CURSEUR_BAS    equ matriceClavier+0 : BIT_CURSEUR_BAS    equ 4 : OCTET_CURSEUR_GAUCHE equ matriceClavier+1 : BIT_CURSEUR_GAUCHE equ 1 struct sprite   positionx defw : positiony defw : adresseDonnees defb : adresseConfiguration defb : sprlargeur defb : sprhauteur defb endstruct struct multi   mapOffset defw : HSSR defb : VSSR defb : colonne defb : ligne defb : adresseDebut defw : crtc12 defb : crtcHL defw : nextBuffer defw endstruct ld sp,#100 ; pile par défaut ailleurs qu'en #C000 car nous avons un buffer ici ld bc,#7F00+%10001100+%00 : out (c),c ; MODE 0 call UnlockAsic : RMR2 ASICON ld hl,palette_fond : ld de,#6400 : ld bc,32 : ldir : ld hl,#000 : ld (#6420),hl ; +border noir ld hl,palette_sprite : ld de,#6422 : ld bc,30 : ldir ld hl,superCarInit : ld de,#4000 : ld bc,1024 : ldir ; copier notre meta sprite RMR2 ASICOFF ld bc,#BC00+1 : out (c),c : ld bc,#BD00+32 : out (c),c : ld bc,#BC00+2 : out (c),c : ld bc,#BD00+42 : out (c),c ld bc,#BC00+6 : out (c),c : ld bc,#BD00+32 : out (c),c : ld bc,#BC00+7 : out (c),c : ld bc,#BD00+34 : out (c),c ld bc,#BC00+12 : out (c),c : ld bc,#BD30 : out (c),c : ld bc,#BC00+13 : out (c),c : ld bc,#BD00 : out (c),c ld ix,tuture ld hl,300 : ld (ix+sprite.positionx),hl ld hl,200 : ld (ix+sprite.positiony),hl ld a,64 : ld (ix+sprite.sprLargeur),a ld a,32 : ld (ix+sprite.sprHauteur),a ld a,#40 : ld (ix+sprite.adresseDonnees),a ld a,0 : ld (ix+sprite.adresseConfiguration),a ld ix,ecran1 : ld a,#80 : ld de,ecran2 : call InitEcran ld ix,ecran2 : ld a,#C0 : ld de,ecran1 : call InitEcran ld ix,ecran1 ; notre structure écran par défaut pour aller scroller LaBoucle call lectureMatriceClavier call UpdateHardware call AfficherTableauSprite ld de,(ix+multi.nextBuffer) : ld ix,de ; permuter la structure de définition du buffer ; on compense rapport à l'écran précédent .Xnegatif ld hl,depx : ld a,(hl) : and #80 : jr z,.XpasNegatif : inc (hl) : call ScrollGauche : jr .Xnegatif .XpasNegatif .Xpositif ld hl,depx : ld a,(hl) : and #7F : jr z,.XpasPositif : dec (hl) : call ScrollDroite : jr .Xpositif .XpasPositif .Ynegatif ld hl,depy : ld a,(hl) : and #80 : jr z,.YpasNegatif : inc (hl) : call ScrollBas : jr .Ynegatif .YpasNegatif .Ypositif ld hl,depy : ld a,(hl) : and #7F : jr z,.YpasPositif : dec (hl) : call ScrollHaut : jr .Ypositif .YpasPositif ld a,(OCTET_CURSEUR_BAS) : and BIT_CURSEUR_BAS : jr nz,.noBas call ScrollBas : jr z,.noBas : ld hl,depy : dec (hl) : ld hl,(scroll_corner_posy) : inc l : inc hl : ld (scroll_corner_posy),hl : jr .noHaut : .noBas ld a,(OCTET_CURSEUR_HAUT) : and BIT_CURSEUR_HAUT : jr nz,.noHaut call ScrollHaut : jr z,.noHaut : ld hl,depy : inc (hl) : ld hl,(scroll_corner_posy) : dec hl : dec l : ld (scroll_corner_posy),hl : .noHaut ld a,(OCTET_CURSEUR_DROITE) : and BIT_CURSEUR_DROITE : jr nz,.noDroite call ScrollDroite : jr z,.noDroite : ld hl,depx : inc (hl) : ld hl,(scroll_corner_posx) : ld bc,4 : add hl,bc : ld (scroll_corner_posx),hl : jr .noGauche : .noDroite ld a,(OCTET_CURSEUR_GAUCHE) : and BIT_CURSEUR_GAUCHE : jr nz,.noGauche call ScrollGauche : jr z,.noGauche : ld hl,depx : dec (hl) : ld hl,(scroll_corner_posx) : ld bc,-4 : add hl,bc : ld (scroll_corner_posx),hl : .noGauche jp LaBoucle ;--------------------------------------------------------------------- AfficherTableauSprite RMR2 ASICON ld iy,tableau_sprite .loop ld hl,(iy+sprite.positionx) : or a : ld de,(scroll_corner_posx) : sbc hl,de : ld (posx_compensee),hl bit 7,h : jr nz,.testGauche ; si c'est négatif on fait le test de gauche ; on teste le débordement à droite (512 pixels mode 2 en largeur) ld de,LARGEUR_ECRAN_MODE_2 : or a : sbc hl,de jp m,.hautBas jp .horsEcran .testGauche ld a,(iy+sprite.sprlargeur) : add l : ld l,a : ld a,h : adc 0 jp m,.horsEcran ; négatif hors écran, reste à tester le zéro ld a,l : or a : jp z,.horsEcran ; on fait un raccourci de calcul car on partait d'une position négative ; quasiment le même code de tester le débordement en vertical .hautBas ld hl,(iy+sprite.positiony) : or a : ld de,(scroll_corner_posy) : sbc hl,de : ld (posy_compensee),hl bit 7,h : jr nz,.testHaut ; si c'est négatif on fait le test du haut ; on teste le débordement en bas de l'écran de 256 lignes ld de,HAUTEUR_ECRAN_LIGNE : or a : sbc hl,de jp m,.affiche jp .horsEcran .testHaut ld a,(iy+sprite.sprhauteur) : add l : ld l,a : ld a,h : adc 0 jp m,.horsEcran ; négatif hors écran, reste à tester le zéro ld a,l : or a : jp z,.horsEcran ; on fait un raccourci de calcul car on partait d'une position négative .affiche ; écriture peu optimisée des 4 sprites (X / Y / zoom) à cause de l'ordre des sprites, on verra plus tard ;) ld bc,#1234 : posx_compensee=$-2 ld de,#1234 : posy_compensee=$-2 ld h,#60 : ld l,(iy+sprite.adresseConfiguration) ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 : ld a,l : add 4 : ld l,a ; sprite 1 push bc : ld a,c : add 32 : ld c,a : ld a,b : adc 0 : ld b,a ; X+32 ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 : ld a,l : add 4 : ld l,a ; sprite 2 pop bc : ld a,e : add 16 : ld e,a : ld a,d : adc 0 : ld d,a ; Y+16 ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 : ld a,l : add 4 : ld l,a ; sprite 3 ld a,c : add 32 : ld c,a : ld a,b : adc 0 : ld b,a ; X+32 ld (hl),c : inc l : ld (hl),b : inc l : ld (hl),e : inc l : ld (hl),d : inc l : ld (hl),%1001 ; sprite 4 jr .auSuivant .horsEcran ld h,#60 : ld l,4 : add (iy+sprite.adresseConfiguration) : ld bc,8 : xor a ; invisibiliser le sprite ld (hl),a : add hl,bc : ld (hl),a : add hl,bc : ld (hl),a : add hl,bc : ld (hl),a ; .auSuivant ld de,{sizeof}sprite : add iy,de ld a,(iy+sprite.sprlargeur) : or a ; tester la largeur du prochain sprite jp nz,.loop ; on reboucle si le prochaine sprite n'a pas une largeur nulle RMR2 ASICOFF ret ;--------------------------------------------------------------------- lectureMatriceClavier ld hl,matriceClavier : ld bc,#f782 : out (c),c : ld bc,#f40e : ld e,b : out (c),c : ld bc,#f6c0 ld d,b : out (c),c : out (c),0 : ld bc,#f792 : out (c),c : ld a,#40 : ld c,d .loop ld b,d : out (c),a : ld b,e : ini : inc a : inc c : jr nz,.loop ld bc,#f782 : out (c),c : ret : matriceClavier defs 10,#FF ;--------------------------------------------------------------------- MACRO calculeAdresseTuile increment exx : ld a,(hl) ; index de la tile dans A if {increment}==0 : elseif {increment}==1 : inc hl : else : add hl,bc : endif exx ; index de la tile dans A / HL'=tileMap ld hl,tuiles : ld b,a : ld c,0 : srl bc : srl bc : add hl,bc ; HL=adresse du début de la tuile MEND MACRO calculeAdresseTuileLigne increment calculeAdresseTuile {increment} ld a,(ix+multi.ligne) : add l : ld l,a ; HL=adresse du début de la tuile à la bonne ligne MEND MACRO calculeAdresseTuileColonne increment calculeAdresseTuile {increment} ld a,(ix+multi.colonne) : add l : ld l,a ; HL=adresse du début de la tuile à la bonne colonne MEND MACRO calculeAdresseTuileLigneColonne increment calculeAdresseTuile {increment} ld a,(ix+multi.ligne) : add (ix+multi.colonne) : add l : ld l,a ; HL=adresse du début de la tuile à la bonne ligne ET bonne colonne MEND MACRO expandNextLineDE ld a,d : add 8 : ld d,a : and #38 : jr nz,@termine ld a,LARGEUR_ECRAN_OCTET : add e : ld e,a : ld a,#C0 : adc d : ld d,a : res 3,d @termine MEND ;--------------------------------------------------------------------- ScrollGauche ;--------------------------------------------------------------------- ld a,(ix+multi.colonne) : or a : jr nz,.goForScroll ld a,(ix+multi.mapOffset) : and LARGEUR_MAP-1 : ret z ; si on est sur la colonne zéro de la tile la plus à gauche... Bye! .goForScroll ld a,(ix+multi.HSSR) : bit 2,a : jr nz,.willDraw : add 4 : ld (ix+multi.HSSR),a : /* always NZ */ ret ; on ne change que le décalage et bye! .willDraw add 4 : and 15 : jr nz,.stillSSR ld hl,(ix+multi.crtcHL) : dec hl : ld (ix+multi.crtcHL),hl ; each word .stillSSR ld (ix+multi.HSSR),a ld hl,(ix+multi.adresseDebut) : ld a,h : and 7 : or l : jr nz,.skip : ld a,h : add 8 : ld h,a : .skip dec hl ; gérer le rebouclage à la décrémentation ld (ix+multi.adresseDebut),hl ld a,(ix+multi.colonne) : dec a : and 3 : ld (ix+multi.colonne),a : cp 3 : jr nz,.stillPosx : dec (ix+multi.mapOffset) : .stillPosx ld hl,(ix+multi.mapOffset) : ld bc,LARGEUR_MAP : exx ; HL'=adresse de la tile BC'=saut de ligne dans la tileMap ld de,(ix+multi.adresseDebut) ; DE=haut de la colonne à rafraichir ; accès direct à l'affichage d'une colonne ;------------------ afficheColonne ;------------------ ld a,(ix+multi.ligne) : or a : jp nz,.clipped ld yh,16 .loopTiles calculeAdresseTuileColonne LARGEUR_MAP ld bc,#0804 repeat 7 : ld a,(hl) : ld (de),a : ld a,l : add c : ld l,a : ld a,d : add b : ld d,a : rend ld a,(hl) : ld (de),a : ld a,l : add c : ld l,a ld a,LARGEUR_ECRAN_OCTET : add e : ld e,a : ld a,#C8 : adc d : ld d,a : res 3,d repeat 7 : ld a,(hl) : ld (de),a : ld a,l : add c : ld l,a : ld a,d : add b : ld d,a : rend ld a,(hl) : ld (de),a ld a,LARGEUR_ECRAN_OCTET : add e : ld e,a : ld a,#C8 : adc d : ld d,a : res 3,d dec yh : jp nz,.loopTiles inc b ; reset Z ret ;---------- .clipped calculeAdresseTuileLigneColonne LARGEUR_MAP ld a,64 : sub (ix+multi.ligne) : rrca : rrca : and 15 : ld b,a : ld c,4 .loopColumnC1 ld a,(hl) : ld (de),a : expandNextLineDE (void) : ld a,l : add c : ld l,a : djnz .loopColumnC1 ld yh,15 call .loopTiles ; dernière tuile clippée calculeAdresseTuileColonne 0 ld a,(ix+multi.ligne) : rrca : rrca : and 15 : ld b,a : ld c,4 .loopColumnC3 ld a,(hl) : ld (de),a : expandNextLineDE (void) : ld a,l : add c : ld l,a : djnz .loopColumnC3 inc b ; reset Z ret ;--------------------------------------------------------------------- ScrollDroite ;--------------------------------------------------------------------- ld a,(ix+multi.mapOffset) : and LARGEUR_MAP-1 : cp LARGEUR_MAP-16 : ret z ; gérer le bord droit ld a,(ix+multi.HSSR) : bit 2,a : jr z,.willDraw : sub 4 : ld (ix+multi.HSSR),a : inc a /* reset Z */: ret .willDraw sub 4 : jr nc,.stillHSSR : jr z,.stillHSSR ld hl,(ix+multi.crtcHL) : inc hl : ld (ix+multi.crtcHL),hl ld a,12 .stillHSSR ld (ix+multi.HSSR),a ld hl,(ix+multi.mapOffset) : ld bc,16 : add hl,bc : ld bc,LARGEUR_MAP : exx ; HL'=adresse de la tile BC'=saut de ligne dans la tileMap ld hl,(ix+multi.adresseDebut) : ld bc,64 : ld a,h : and %11111000 : ld d,a : add hl,bc : ld a,h : and 7 : or d ; gère le rebouclage de bloc! ex hl,de ; DE=haut de la colonne à rafraichir call afficheColonne ld a,(ix+multi.colonne) : inc a : and 3 : ld (ix+multi.colonne),a : jr nz,.stillPosx : inc (ix+multi.mapOffset) : .stillPosx ld hl,(ix+multi.adresseDebut) : inc hl : ld a,h : and 7 : or l : jr nz,.skip : ld a,h : sub 8 : ld h,a : .skip : ld (ix+multi.adresseDebut),hl inc b ; reset Z ret ;--------------------------------------------------------------------- ScrollBas ;--------------------------------------------------------------------- ld hl,(ix+multi.mapOffset) : ld a,hi(tileMap+(HAUTEUR_MAP-16)*LARGEUR_MAP) : cp h : ret z ; trop bas, on ne fait rien! ; la tuile en bas sera 16 lignes de tuiles plus bas, soit 2048 octets de tileMap de largeur 128 ld bc,16*LARGEUR_MAP : add hl,bc : exx ; ajouter 16x128 à l'offset de tuile car on va afficher en bas de l'écran + sauvegarde dans HL' ld de,(ix+multi.adresseDebut) ; écran carré, calculs simples, le bas revient en haut et vice versa :) call afficheTuilesHorizontalesDeuxLignes ; mettre à jour les informations courantes ld a,(ix+multi.ligne) : add 8 : cp 64 : jr nz,.pasDeChangementDeTuile ; ligne contient l'offset de début de la ligne suivante ld hl,(ix+multi.mapOffset) : ld bc,LARGEUR_MAP : add hl,bc : ld (ix+multi.mapOffset),hl : xor a ; passer à la tuile dessous .pasDeChangementDeTuile ld (ix+multi.ligne),a ; valider la ligne de tuile ld hl,(ix+multi.adresseDebut) : call NextLineHL : call NextLineHL : ld (ix+multi.adresseDebut),hl ld a,(ix+multi.VSSR) : add #20 : and #60 : ld (ix+multi.VSSR),a : jr nz,.pasDeChangementDeBloc ld hl,(ix+multi.crtcHL) : ld bc,32 : add hl,bc : ld (ix+multi.crtcHL),hl ; adresse CRTC augmente de 32 mots si le bloc change .pasDeChangementDeBloc or 1 ; reset Z ret ;--------------------------------------------------------------------- ScrollHaut ;--------------------------------------------------------------------- ld hl,(ix+multi.mapOffset) : ld a,hi(tileMap) : cp h : jr nz,.okPourLeScroll ; si on est près du début on doit contrôler le "Y" ld a,l : cp LARGEUR_MAP-1 : jr nc,.okPourLeScroll ; si on est sur la première ligne, on doit regarder la ligne de tuile! ld a,(ix+multi.ligne) : or a : ret z ; tout en haut, aurevoir! .okPourLeScroll ; on peut scroller! ; mettre à jour les informations courantes ld a,(ix+multi.ligne) : sub 8 : jr nc,.pasDeChangementDeTuile ; ligne contient l'offset de début de la ligne suivante ld hl,(ix+multi.mapOffset) : ld bc,-LARGEUR_MAP : add hl,bc : ld (ix+multi.mapOffset),hl : ld a,64-8 ; passer à la dernière ligne de la tuile dessous .pasDeChangementDeTuile ld (ix+multi.ligne),a ; valider la ligne de tuile ld hl,(ix+multi.adresseDebut) : call PreviousLineHL : call PreviousLineHL : ld (ix+multi.adresseDebut),hl ld a,(ix+multi.VSSR) : sub #20 : and #60 : ld (ix+multi.VSSR),a : cp #60 : jr nz,.pasDeChangementDeBloc ld hl,(ix+multi.crtcHL) : ld bc,-32 : add hl,bc : ld (ix+multi.crtcHL),hl ; adresse CRTC baisse de 32 mots si le bloc change .pasDeChangementDeBloc ; on affiche après en remontant ld hl,(ix+multi.mapOffset) : exx ld de,(ix+multi.adresseDebut) ; on continue directement dans l'affichage des lignes ;------------------------------- afficheTuilesHorizontalesDeuxLignes ;------------------------------- push de .Paires ld a,(ix+multi.colonne) : or a : jp nz,.routineClippee calculeAdresseTuileLigne 1 : ldi 4 : res 3,d : ld (suiteImpaire.imp0+1),hl ; adresse de la ligne suivante de la tuile à la bonne ligne .loop repeat 15,x calculeAdresseTuileLigne 1 : ldi 4 : res 3,d : ld (suiteImpaire.imp{x}+1),hl ; adresse de la ligne suivante de la tuile à la bonne ligne rend jp suiteImpaire.NonClippee ;--------------- .routineClippee calculeAdresseTuileLigneColonne 1 ld a,4 : sub (ix+multi.colonne) : ld c,a : ld (suiteImpaire.lenFirst+1),a ld b,0 : ldir : res 3,d ld a,(ix+multi.colonne) : add l : ld l,a : ld (suiteImpaire.impFirst+1),hl ; adresse de la ligne suivante de la tuile à la bonne colonne repeat 15,x calculeAdresseTuileLigne 1 : ldi 4 : res 3,d : ld (suiteImpaire.imp{x}+1),hl ; adresse de la ligne suivante de la tuile à la bonne ligne rend calculeAdresseTuileLigne 0 ld c,(ix+multi.colonne) ld b,0 : ldir : res 3,d ld a,4 : sub (ix+multi.colonne) : add l : ld l,a : ld (suiteImpaire.impLast+1),hl ; adresse de la ligne suivante de la tuile à la bonne colonne suiteImpaire .clippee pop de : ld a,d : add 8 : ld d,a .impFirst ld hl,#1234 .lenFirst ld c,#12 ld b,0 : ldir : dec de : res 3,d : inc de : set 3,d call .loop .impLast ld hl,#1234 ld c,(ix+multi.colonne) ld b,0 : ldir inc b ; reset Z ret .NonClippee pop de : ld a,d : add 8 : ld d,a .imp0 ld hl,#1234 : ldi 3 : ld a,(hl) : ld (de),a : res 3,d : inc de : set 3,d .loop repeat 15,x .imp{x} ld hl,#1234 : ldi 3 : ld a,(hl) : ld (de),a : res 3,d : inc de : set 3,d rend or 1 ; reset Z ret ;--------------------------------------------------------------------- InitEcran ; IX = structure buffer ; A = poids fort de la page vidéo ld (ix+multi.nextBuffer),de ld hl,depx : ld (hl),0 ld hl,depy : ld (hl),0 ld hl,tileMap ld (ix+multi.mapOffset),hl ld hl,0 ld (scroll_corner_posx),hl ld (scroll_corner_posy),hl ld (ix+multi.HSSR),h ld (ix+multi.VSSR),h ld (ix+multi.colonne),h ld (ix+multi.ligne),h ld (ix+multi.crtcHL),hl ld h,a : ld (ix+multi.adresseDebut),hl rrca : rrca : ld (ix+multi.crtc12),a ; Afficher les tuiles sur tout l'écran ld de,(ix+multi.adresseDebut) ld ix,tileMap ; on n'utilise plus la structure à partir de là ld yh,16 ; 16 tuiles en hauteur afficheLigne ld yl,16 ; 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 : srl hl ; x 256 / 4 c'est la taille de nos tuiles (64 octets) ld bc,tuiles : add hl,bc ; on a l'adresse de la tile ld a,16 afficheLigneTuile push de : ldi 4 : pop de exa : call NextLineDE : exa dec a : jr nz,afficheLigneTuile pop hl : ld bc,4 : add hl,bc : ex hl,de ; se placer juste à côté de la tuile précédente dec yl : jr nz,afficheTuile ld bc,LARGEUR_MAP-16 : add ix,bc ; revenir à la ligne de tuile suivante pop hl : ld bc,128 : add hl,bc : ex hl,de ; se placer sous les tuiles à gauche dec yh : jr nz,afficheLigne ret ;--------------------------------------------------------------------- NextLineHL ld a,h : add 8 : ld h,a : and #38 : ret nz ; tester le changement de bloc sur n'importe quelle page ld a,64 : add l : ld l,a : ld a,#C0 : adc h : ld h,a : res 3,h : ret PreviousLineHL ld a,h : sub 8 : ld h,a : and #38 : cp #38 : ret nz ; test du chgt de bloc (bis) ld a,l : add #C0 : ld l,a : ld a,#3F : adc h : ld h,a : set 3,h : ret NextLineDE ld a,d : add 8 : ld d,a : and #38 : ret nz ; tester le changement de bloc sur n'importe quelle page ld a,64 : add e : ld e,a : ld a,#C0 : adc d : ld d,a : res 3,d : ret ;--------------------------------------------------------------------- UpdateHardware call WaitVBL RMR2 ASICON ld a,(ix+multi.HSSR) : or (ix+multi.VSSR) : or #80 : ld (#6804),a ld hl,(ix+multi.crtcHL) : ld a,h : and 3 : or (ix+multi.crtc12) : ld bc,#BC00+12 : out (c),c : inc b : out (c),a inc c : dec b : out (c),c : inc b : out (c),l RMR2 ASICOFF ret ;--------------------------------------------------------------------- UnlockAsic ld bc,#BCFF out (c),c out (c),0 ld hl,%1001000011101010 .loop out (c),c : ld a,h : rlca : ld h,l : ld l,a srl c : res 3,c : and #88 : or c : ld c,a : cp #4D : jr nz,.loop ld a,#CD : out (c),a : out (c),a : ret ;--------------------------------------------------------------------- WaitVBL ld b,#F5 : noVBL in a,(c) : rra : jr c,noVBL VBL in a,(c) : rra : jr nc,VBL : ret palette_fond: defw #000,#600,#060,#006,#666,#0F0,#00F,#F06,#6F0,#FF0,#FFF align 256 : tuiles incbin 'carlosMapRatio.bin' palette_sprite defw #000,#002,#300,#040,#440,#550,#090,#4B0,#9B0,#0F0 superCarInit incbin 'tutureAlpha.bin',0,1024 ; seulement 1024 octets soit 4 sprites ou une étape ; et on se déclare deux structures pour un double buffer struct multi ecran1 struct multi ecran2 depx defb 0 depy defb 0 scroll_corner_posx defw 0 scroll_corner_posy defw 0 tableau_sprite struct sprite tuture struct sprite terminator org #4000 : tileMap include 'carlosMapRatio.tilemap'

Notre voiture est en place, si on scrolle, elle reste immobile sur le fond. Si on arrive en butée du scrolling, la voiture ne bouge pas. Maintenant que notre gestion est à priori ok, on va pouvoir commencer à bouger le Sprite sur le décor dans [ l'article suivant! ]