Déterminer de quel côté a lieu la collison

[mikaknight]

Bonjour,

cela fait un moment que je cherche une façon de détecter dans quel côté à lieu la collision avec un rectangle(tile). je veux savoir si c'est à gauche, haut, bas ou à droite.

J'arrive à détecter la collision avec un tile, ça ce n'est pas un problème, mais je voudrais juste détecter de quel côté je touche ce tile. Cette fonction, je souhaite évidement le faire après avoir détecter une collision avec un tile.

Un extrait de mon code actuel(qui ne marche pas):

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public int cote_Collision(Rectangle heros, Rectangle tiles) {
 
        int leftW, leftB;
        int rightW, rightB;
        int topW, topB;
        int bottomW, bottomB;
 
        leftB = heros.x;
        rightB = heros.x + heros.width;
        topB = heros.y;
        bottomB = heros.y + heros.height;
 
        leftW = tiles.x;
        rightW = tiles.x + tiles.width;
        topW = tiles.y;
        bottomW = tiles.y + tiles.height;
 
 
        if((topB >= topW) && (bottomB >= bottomW))
        {
        	// collision droite
        	if(rightB > rightW)
            {
            	return DROITE;
            }
        	// collision gauche
            if(leftB < leftW) {
            	return GAUCHE;
            }
        }
 
 
        if((leftB <= leftW) && (rightB <= rightW))
        {
        	// collision haut
        	if(topB < topW){
            	return HAUT;
            }
 
            // collision bas
            if(bottomB > bottomW) {
            	return BAS;
            } 
        }
 
 
        return 0;
	}

HAUT, BAS, GAUCHE, DROITE étant des constantes int.

Si quelqu'un pouvait m'aider, ce serait sympa.

Y m'semble que c'est plus simple que ça la detection gauche droite haut bas si tu calcules les centres des rectangle

par exemple si tu as trouvé la penetration la plus courte sur x alors:

Code :

if ( rectangleACentre_x > rectangleBCentre_x ) return LEFT; else return RIGHT;

ya surement un calcul qui permet d'éviter de calculer les centres mais je te guide sur la bonne piste


Sinon c'est pour quel type de jeu ? Quand on s'enquiquine à faire des bbox collision sur les tuiles c'est en général pour un jeu en vue de dessus ou iso3d pour avoir une selection super précise du renvoi sur x et y.

Si c'est pour un jeu de plateforme y'a beaucoup plus simple il suffit de décomposer le mouvement sur x puis y.

[mikaknight]

Merci de ta réponse punkcoders, mais j'ai déjà trouvé ma réponse.
Voici l'algorithme utilisée pour ceux qui serait intéressé:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public int cote_Collision(Rectangle heros, Rectangle tile) {
 
 
        float w = (float) (0.5 * (heros.width + tile.width));
        float h = (float) (0.5 * (heros.height + tile.height));
        float dx = (float) (heros.getCenterX() - tile.getCenterX());
        float dy = (float) (heros.getCenterY() - tile.getCenterY());
 
        if (dx <= w && dy <= h)
        {
            // collision!
            float wy = w * dy;
            float hx = h * dx;
 
            if (wy > hx)
            {
                if (wy > -hx)
                {
                    // collision at the top 
                	return HAUT;
                }
                else
                {
                	// on the left
                	return GAUCHE;
                }
            }
            else
                if (wy > -hx)
                {
                    // on the right 
                	return DROITE;
                }
                else
                {
                    // at the bottom
                	return BAS;
                }
        }
		return 0;
 
	}

C'est du Java, mais c'est très facile à adapter dans d'autres langages.

Sinon pour te répondre, c'est un jeu vue de dessus, un RPG à l'ancienne. Il est déjà bien avancé, j'ai quasi fini le moteur du jeu. Là, je finalise l'éditeur de niveau et après, je vais commencé à créer les maps.