Détection de colisions - Page 1

Admettons qu'on a un sprite qui se déplace entre d'autres sprt.

le vaisseau (le sprite qui se déplace) peut aller dans les 8 directions, par pas allant de 0 à 5 pixels pr cycle du programme

les autres sprites (des murs) peuvent aller vers le bas de l'écran (à la vitesse de 2 pixels par cycle) ou vers le haut (à la vitesse de 1 pixel par cycle) si le vaisseau recle en étant en bas de l'écran.


On veut que le vaisseau ne puisse pas traverser les murs, ni même les chevaucher de plus de 2-3 pixels... comment faire ?


(j'utilises actuellement des PxlTest sur un plan qui ne contient que les masks des sprites des murs... mais il y a surement mieux !!!)
(rappel : il fo quelques chose de super précis !!! et qui soit capable de dire par quel côté du vaisseau la colision se fait)



quelques variables que le prog propose :
# vaisseau_recule vaut TRUE si les murs remontent apr,pas de de 1 pix
et FALSE si non.
# avancent_murs vaut TRUE si les murs descendent de 2 pix par cycle sur l'écran...

Fais star68k et ne te torture pas

Hum... plus serieusement, cave blaster utilise des pxltest il me semble. Enfin plutot une fonction identique à pxltest mais plus rapide que celle du tios.

Heureusement que c'est que de la 2D

j'utilises des PxlTest (ceux de Xlib), mais l'algo qui utilises de PxlTest ne doit pas être la meilleure solution (même si c'est la seconde sur le plan facilité en général, voire la plus simple ds ce cas précis vu que l'arrière plan est en mouvement)

Et je ne bosserai pas sur TI-Craft avant longtemps : le peu de temps que je peu coder, je le passe sur KryptonII (j'ai eu qu'un heure en gros ce WE )

NB: ce jeu ne sortira pas en bêta avant l'Open-TI Lyonnais (même quelques temps après, pr motiver les gens à venir lol) : ce sera mon "exclue"

Les pauvres
Au derniers Open-TI, on avait une demo de CF, une beta de FZ Bomber et une autre de SMB3

On fait avec ce qu'on peut...
Au dernier Open-TI, on avait l'auteur de CF !!!
(il était pas monté à Paris, si ?)

Une idée :

Tu utilises un plan avec les masques des murs ; ensuite tu fais un AND entre chaque ligne de ton sprite et l'endroit où le sprite s'affiche à l'écran. Selon le résultat obtenu (soit 0 -> pas de collision) tu sauras où ta collision a lieu au pixel près.

attention a pas trop seloigner du sujet..;

MadKeyBoard> oué, on m'a parlé de cete technique (je sais po trop comment la mettre en oeuvre par contre )

euh au fait squale92 ton site sur multimania est mort il me semble....
et ou on peut trouver la derniere version de krypton?

oué, il est grave mort, puisque Multimania m'a banni cette fois : je peux même plus recréer de site à mon nom.
Mais le tuto est en plein transfert *ailleurs* (le tuto ASM, vu qu'il est court, est déjà transféré... mais le tutoC, je suis en train de revoir ce qui hibou a fait à partir de ce que j'avais fait (nouveautés ds TIGCC, petits rajouts, et autres), et fodra ensuite que Verstand le mette en page)
EN attendant, le tuto est toujours sur Ti-Fr...

la dernière version de Krypton... sur mon DD... et celui ce TI-cas.
=> ne sortira pas av les résultats, quels qu'ils soient.
(de toute fazçon, je suis déjà en train de bosser sur KryptonII... et qd je regarde ce que j'avais fait comme merdes ds Krypton, j'ai honte de mon code... mais bon, il sera pas open-source )

Tu te pleins de ton compte qui a été effacé, mais tu peux pas en recréer un ailleurs ?

putain ces trous de bal de multimania ils ont pas encore remis les comptes!! si jamais ils ont viré mes bdd je,je,je... grrrr...

PAAAFFFFFF !!!!!!!!!

squale92 > oué, on m'a parlé de cete technique (je sais po trop comment la mettre en oeuvre par contre )

Si tu sais comment marche une routine de sprite (avec les décalages de bits), tu utilises le même principe.

Ton décor est dans un masque graphique où 0 = place libre, 1 = mur. Ton masque de sprite est également fait de 0 = pas de sprite, 1 = sprite.

Tu fais mot par mot un AND entre les données du sprite et le fond (comme dans une routine de sprite standard)

Si ton mot résultat comporte des 1 quelque part, c'est que forcément à ce bit là, ton masque de fond était à 1, et ton masque de sprite était à 1.

Tu sais donc qu'une collision a eu lieu, et à quelque bit.

squale> c vrai qu'ils font chier à multimania

Tu peux regarder la source de phoenix.
Mais avec cette tehcniaque, on ne sait pas de quel cote a eu lieu la collision.

si on peut savoir...
si le resultat est supperieur 2^5-1 ...

A oui, c'est vrai.

OK, v tenter ça...
mais si je comprend bien, il faut que je teste ceci pour tous les mots de l'écran, pour chauqe ligne de sprite ?
ça fait 15 mots par ligne d'écran, non ?
15*128 => bcp de tests, je me trompe ?

Houla ! Revises tout d'abord ta routine d'affichage de sprites. Ensuite tu ne detecteras que pour le contour du sprite (commme pour l'affichage).

Arf, oué, c vrai que je peux ne tester que autour du sprite, comme je le fais déjà avec les PxlTest
pr voir comment la routine de SPRT fonctionne, ça va être plus dur, vu que je suis pas bien doué en ASM mais bon, v déjà essayer comme ça.



En gros, faut que je fasse quelques chose de ce style ? :

sprt_mask = le mask du vaisseau
x_v = la position du coin sup gauche
y_v = la position en Y du coin sup gauche
fond = l'adresse du coin gauche de l'écran virtuel

*(fond+y_v*30+x_v/8) & *sprt_mask
un AND entre le fond : *(fond+y_v*30+x_v/8) (en considérant des lignes de 30 octets même si c'est po le cas sous XLib, je changerai ça)

long Collision16(short x,short y,short h,unsigned short* sprite, void* mur_colllision){

    register long           addr = (long)dest+(y<<5)-(y<<1)+((x>>3)&0xfffe);
    register unsigned short cnt  = 16-(x&15);
   register long temp;

    for (;h;h--,addr+=30)
	{
	temp = *(long*)addr&((long)(*sprite++)<<cnt);

	if (temp)
		return temp;
	}
	return 0;
}

[edit]Edité par PpHd le 07-03-2002 à 14:07:11[/edit]

pourquoi faire une detection au pixel quand un detection avec deux ou 3 rectangles peut tres bien faire l'affaire ?

PpHd > tiens, ça me rappelle quelque chose, ça... à améliorer, renvoie également le numéro de ligne où la collision a lieu :

Deux paramètres supplémentaires :
line = adresse où stocker le numéro de ligne
mask = adresse où stocker masque de la collision (au format sprite)
la fonction renvoie -1 si une collision a lieu, sinon 0

int Collision16(short x,short y,short h,unsigned short* sprite, void* dest, short *line, unsigned short *mask){

register long addr = (long)dest+(y<<5)-(y<<1)+((x>>3)&0xfffe);
register unsigned short cnt = 16-(x&15);
register long temp;

for (;h;h--,addr+=30)
{
temp = *(long*)addr&((long)(*sprite++)<<cnt);

if (temp) {
*line = (addr-dest)/30;
*mask = (unsigned short)(temp>>cnt);
return -1;
}
return 0;
}


liquid > je pense que c'est ce qu'il y a de plus simple, étant donné les contraintes énoncées plus haut

le truc de PpHd marche pr les écrans de 30 octets par ligne...
fo maintenant que je voie pr les Gplan de Xlib...

Bon, j'utilises ceci :

long Collision16(short x, short y, short h, unsigned short* sprite, void* mur_colllision)
{
//	register long addr = (long)mur_colllision+(y<<5)-(y<<1)+((x>>3)&0xfffe);
	
	register long addr = 0;
	register unsigned short cnt = 0;
  register long temp = 0;
  
  
//  y += 32;
  x += 32;
  
  
  addr = (long)mur_colllision+32*38+ y*38 + ((x/8)&0xfffe);
  cnt = 16-(x&15);
  
  for ( ; h ; h--,addr+=38)
	{
		temp = *(long*)addr&((long)(*sprite++)<<cnt);
	
		if(temp) return temp;
	}
	return 0;
}

(je sais, c po du tout optimisé)
mais ça marhc epo comme il faut : il dit toujours (ou presque) qu'il y a colision
est-ce que quelqu'un voit la connerie que g pu faire ?

essaie de debugger avec des conditions plus simples (mur_collision vide à part un pixel, sprite remplacé par un rectangle plein)

tu verras très vite où est le bug...

long Collision16(short x,short y,short h,unsigned short* sprite, void* mur, short *line){ 

        register long addr = (long)mur+y*38+(((x+32)>>3)&0xfffe); 
        register unsigned short cnt = 16-(x&15); 
        register long temp; 
	*line = h;

        for (;h;h--,addr+=38) 
        { 
        temp = *(long*)addr&((long)(*(sprite++))<<cnt); 
        if (temp) { 
        	*line -= h; 
        	return (unsigned short)(temp>>cnt); 
	        } 
	}
        return 0; 
        } 

C'est bon !!!
J'ai réussi à en tirer ce qu'il me fallait en l'adaptant un peu !
Merci à tous !