J'ai enfin corrigé le problème de la Bille qui était peu visible.
Voilà j'ai constaté qu'avec mon ancienne méthode de redessiner toute la MAP après casser une brique que le jeu perdait énormément de frames quand la bille feu détruisait toutes les briques sans collisions et dans d'autres cas... J'ai donc pensez à redessiner que le bout de décors manquant suivant des calculs sur le sprite, mes routines fonctionnent mais il ce pose 2 problèmes que je pense peut être améliorer or je ne vois pas comment:
Voilà la routine en C qui redessiner le bout de décors à l'endroit où est détruit la brique.
//Dessine bout de background (casse brique)
void DrawMapBackground (unsigned char xblock, unsigned char yblock)
{
short x=(xblock*BLOCK_SIZEX)+START_X;
short y=yblock*BLOCK_SIZEY;
//Modulo 2 block*2 octets
unsigned char xoffset=((xblock&0x01)^1)*2+1;
//(y-Numéro du sprite*32)*16 octets Numéro du sprite=(y-Début)/Size y
unsigned short yoffset=(y-(((y-START_X)/32)*32))*16;
//Dessine Small background
DrawSmallBackground (x,y,xoffset+yoffset,DecorsBlocks,BufferMap);
}
x et y contiennent la coordonnée de la brique grâce à la matrice...
xoffset contient l'offset d'affichage du sprite de 32x32 du décors suivant x.
yoffset contient l'offset d'affichage du sprite de 32x32 du décors suivant y.
START_X est une constante est vaut 8 ainsi que START_Y.
Dans yoffset j'ai mis 16 pour la raison est que j'utilise un buffer pour le sprite de telle sorte qu'il fasse 64x64 au lieu de 32x32.
DecorsBlocks coorespond au buffer du sprite faisant 64x64 et BufferMap est le buffer d'affichage de la zone de briques.
Le problème est que je ne vois pas comment optimiser les calculs de xoffset et surtout yoffset, je trouve ça plutôt lent!
De plus j'utilise un buffer de 1024 octets pour un sprite de 64x64 au format entrelacé et je trouve ça énorme, y aurait-il un autre moyen en évitant ce buffer?
De plus voici la routine s'occupant d'afficher le bout de sprite désiré.
Elle affiche le sprite en 16x7 soit la taille d'une brique.
BufferMap fait 3696 octets par plan.
Y a t-il divers possibilités d'optimiser cette routine?
;C prototype: void DrawSmallBackground (short x, short y, unsigned short offset, void *sprite, void *dest);
;
;void DrawSmallBackground (register short x asm("%d0"),
; register short y asm("%d1"),
; register unsigned short offset asm("%d2"),
; register void *sprite asm("%a0"),
; register void *dest asm("%a1"));
;Ici le sprite fait 7 pixels de hauteur et 16 pixels de largeur
xdef DrawSmallBackground
DrawSmallBackground:
move.l d3,-(a7)
add.w d1,d1
add.w d1,d1 ;y*2
move.w d1,d3
lsl.w #3,d3 ;y*32
sub.w d1,d3 ;32-2=y*30
lsr.w #3,d0 ; d3 = x/16
add.w d0,d3 ; d1 = 18*y + x/16
adda.w d3,a1 ; a0 += offset
;Offset sprite
add.w d2,a0
;DrawSprite LIGHTPLANE
moveq.l #6,d3
DrawSprite_0:
move.b (a0),(a1)
move.b 1(a0),1(a1)
lea.l 28(a1),a1
lea.l 16(a0),a0
dbra.s d3,DrawSprite_0
;DrawSprite DARKPLANE
lea.l 3696-28*7(a1),a1
lea.l -16*7+8(a0),a0
moveq.l #6,d3
DrawSprite_1:
move.b (a0),(a1)
move.b 1(a0),1(a1)
lea.l 28(a1),a1
lea.l 16(a0),a0
dbra.s d3,DrawSprite_1
move.l (a7)+,d3
rts
Ses routines sont assez crutial pour le jeu et donc doivent être hyper optimiser or je ne vois pas comment optimiser plus. En effet le jeu aura la possibilité d'avoir énormément d'interaction et principalement ce genre de routines qui risque d'être appellé très souvent...
Merci de vos réponses.
(Désolé pour ce post avec beaucoups de codes ce que Vertyos n'aime pas, mais je ne vois pas la meilleur façon de présenter ceci sans que vous croyez que je n'ai pas chercher et essayer de trouver un algorithme).
)
