Discussion :

[Mic75]

Bonjour à tous,
Je souhaiterais savoir si quelqu'un a déjà utilisé la librairie SDL_Collide qui comporte quelques fonctions intéressantes pour la gestion des collisions sous SDL.

Pour ma part la compilation ne passe pas si je l'ajoute à mon projet (devcpp).
Merci d'avance pour les réponses.

[fearyourself]

Non désolé, je n'ai jamais essayé cette bibliothèque.

Par contre, la gestion des collisions n'est pas tellement difficile à gérer (dépendant du style de collision)

Tu cherches à gérer quel genre de collision?
Jc

[Mic75]

Ben en fait je tiens juste à vérifier si 2 surface ne se chevauche pas.
C'est vrai que c'est pas compliqué du tout à gérer, et ce que j'ai codé actuellement fonctionne très bien.

Mais comme il existe une extension contenant un lots de fonctions, j'me suis que ça allègerait mon code et que c'était surement plus optimisé.

Enfin bref, je pense que je ne vais pas inclure SDL_Collide, juste utiliser les fonctions qui m'intéressent.

[fearyourself]

Ben en fait je tiens juste à vérifier si 2 surface ne se chevauche pas.
C'est vrai que c'est pas compliqué du tout à gérer, et ce que j'ai codé actuellement fonctionne très bien.

Mais comme il existe une extension contenant un lots de fonctions, j'me suis que ça allègerait mon code et que c'était surement plus optimisé.

Enfin bref, je pense que je ne vais pas inclure SDL_Collide, juste utiliser les fonctions qui m'intéressent.

Bonsoir,

Ce sujet en parle : http://www.developpez.net/forums/sho...ht=SDL_Collide

Et moi je fais ceci pour tester une collision entre deux rectangles :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Fonctions qui gerent les collisions
bool Physique::collisionRect(double x1, double y1, double w1, double h1,
                        double x2, double y2, double w2, double h2)
{
        if(x1<=x2)
                {
                if(x1+w1>x2)
                        {
                        return (((y1<y2)&&(y1+h1>y2)) ||
                                ((y1>y2)&&(y2+h2>y1)) ||
                                (y1==y2));
 
                        }
                }
        else
                {
                        return collisionRect(x2,y2,w2,h2,x1,y1,w1,h1);
                }
        return false;
}

Qu'on pourrait optimiser en ne faisant pas l'appel récursif (bien qu'un compilateur bien paramétrer le mettrait en inline en principe)

Jc

[Mic75]

Dans le principe ça ressemble à ce que j'ai fait (en plus élégant ).
Seulement la récursivité ça sert à quoi ici ? C'est pour économiser des lignes ?

Qu'on pourrait optimiser en ne faisant pas l'appel récursif (bien qu'un compilateur bien paramétrer le mettrait en inline en principe)

Je comprend pas trop

En tout cas merci pour le lien vers le poste sur SDL_Collide, ça a confirmé mes inquiétudes quand à la validité du code (point virgule manquant et polymorphisme impossible)

[fearyourself]

Seulement la récursivité ça sert à quoi ici ? C'est pour économiser des lignes ?

Oui exactement!

[Mic75]

Bon, ben je vais utiliser ta solution, c'est vraiment pas mal, et plus léger que ce que j'ai fait de mon coté.

Merci encore

[fearyourself]

Bon, ben je vais utiliser ta solution, c'est vraiment pas mal, et plus léger que ce que j'ai fait de mon coté.

Merci encore

Voici une version utilisant des surfaces à la place des doubles :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//Fonctions qui gerent les collisions
bool Physique::collisionSurf(SDL_Surface *s1, SDL_Surface *s2)
{
          if(s1->x<=s2->x)
                {
                if(s1->x+s1->w>s2->x)
                        {
                        return (((s1->y<s2->y) && (s1->y+s1->h> s2->y)) ||
                                ((s1->y>s2->y)&&(s2->y+s2->h>s1->y)) ||
                                (s1->y==s2->y));
 
                        }
                }
        else
                {
                        return collisionRect(s2,s1);
                }
        return false;
}

Jc

[mat.M]

Par contre, la gestion des collisions n'est pas tellement difficile à gérer (dépendant du style de collision)
Jc

(!)
La détermination du chemin ( path-finding ) et les collisions c'est ce qu'il y a de plus dur à mettre au point dans un jeu.
Je mets quiconque au défi de faire quelque chose un brin perfectionné

[fearyourself]

(!)
La détermination du chemin ( path-finding ) et les collisions c'est ce qu'il y a de plus dur à mettre au point dans un jeu.
Je mets quiconque au défi de faire quelque chose un brin perfectionné

Il fallait lire :

Par contre, la gestion des collisions n'est pas tellement difficile à gérer (dépendant du style de collision)

Donc je me mettais dans la discussion d'une gestion de collisions pour deux surfaces rectangulaires...

Bien sûr si on cherche un code optimisé gérant 3000 objets, il ne faut pas utiliser ce code, d'ailleurs je pense que j'y suis allé fort quand je l'ai fait (ma fonction). A mon avis, on pourrait limiter le nombre de tests...

Ah, en effet, en regardant le code de SDL_Collision, on peut simplifier cette fonction en faisant ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
/*
	SDL bounding box collision tests (works on SDL_Rect's)
*/
int SDL_CollideBoundingBox(SDL_Rect a , SDL_Rect b)
{
	if(b.x + b.w < a.x)	return 0;	//just checking if their
	if(b.x > a.x + a.w)	return 0;	//bounding boxes even touch
 
	if(b.y + b.h < a.y)	return 0;
	if(b.y > a.y + a.h)	return 0;
 
	return 1;				//bounding boxes intersect
}

Ce qui est encore plus propre et plus rapide (bien que je ne cherchais pas la rapidité mais ce code est en plus plus simple à comprendre donc....

Jc

[Mic75]

Yep c'est encore mieux, j'ai hésité vu que l'extension est codé à la nawak, mais c'est vrai que c'est encore plus léger.