Aller au menu - Aller au contenu

Icône Théorie des collisions

Avatar
Par Avatar Fvirtman
Mise à jour : 29/07/2010
Difficulté : Intermédiaire Intermédiaire
1 398 visites depuis 7 jours, classé 95/786
Vous programmez un jeu vidéo, et vous vous intéressez aux collisions d'objets.

Est-ce-que mon personnage touche un ennemi ? Est-ce-qu'il touche le sol ? Est-ce-que mon curseur de souris, un viseur, touche un ennemi ? Tout ceci, ce sont des tests de collision. Les collisions sont un aspect fondamental de tout jeu d'action ou d'animation en général.

Nous considèrerons une ou plusieurs fonctions Collision qui prendront en paramètre 2 objets, ou un objet et un monde fait de sols et de murs. Et ces fonctions renverront simplement un booléen, ayant donc pour valeur oui ou non, selon si ça touche ou non.

Toute la gestion des collisions s'appuiera sur ces fonctions.
Selon votre jeu, selon vos besoins, les fonctions de collisions seront différentes, mais renverront toujours "oui" ou "non".

Comment implémenter ces fonctions de collision en fonction de vos besoins ? C'est la raison d'être de ce tutoriel, qui vous présentera plusieurs méthodes.

Les quelques fonctions d'exemple qui illustreront les différents cas seront codées en C, cependant facilement transcodables en d'autres langages.
Retour en haut
Ce cours est composé des parties suivantes :
Retour en haut
Voici donc quelques techniques pour la gestion des collisions.
Plus tard, je rajouterai des chapitres pour parler d'autres techniques, comme les collisions par masque, le pixel perfect, le quadtree, l'octree, le BSP...

Si vous connaissez d'autres techniques de collisions auxquelles je n'ai pas pensé, envoyez moi un message privé (ne postez pas cela dans les commentaires du tuto).

Merci de votre lecture. :)
Retour en haut

Partager

Retour en haut
25 commentaires pour "Théorie des collisions"
Note moyenne : 3.83 / 4 (158 votes)
Pseudo Commentaire
Hors ligne Mrpsychopathe # Posté le 18/09/2011 à 17:56:10

Avis : Très bon

Pas d'autres mots : génial! C'est clair, élégant, rapide et fonctionnel... que demander d'autre? En plus ca sert pour une foultitude de choses autre que les collisions : je m'en sert actuellement dans un petit moteur à raycasting (comme Doom), et ca marche parfaitement!
Hors ligne solix # Posté le 01/11/2011 à 20:42:37
101010
Avatar

Ville : Pontault-combault
Pays : France métropolitaine

 Vraiment super ce tuto ! Très utile pour qui veut programmer un jeu !

J'avou que j'aurai bien aimer voir a collision AABB/OBB (2D et 3D)
J'ai hate que tu étoffe la partie sur la 3D ! :D
Hors ligne neo_xnitro # Posté le 03/11/2011 à 22:29:51

Super tuto qui ma fait avancer dans mon projet.
Pour ceux qui sa intéresse, une méthode de collision 3D pour pouvoir retourner la coordonnée qui à provoqué la collision et la restaurer.

Code : C++
 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
// Appelle de la fonction, je passe les coordonnées déplacé + les coordonnées avant le déplacement.

            switch(ListeDesForme.GetSpec(i)->CollisionDirection(x,y,z,last_x,last_y,last_z))
            {
                    case COLLISION_X: x = last_x;
                    break;
                    case COLLISION_Z: z = last_z;
                    break;
                    case COLLISION_Y: y = last_y;
                    break;
                    case COLLISION_XYZ:
                        x = last_x;
                        y = last_y;
                        z = last_z;
                    break;
            }

// La méthode
int Cube::CollisionDirection(double X,double Y,double Z, double last_X, double last_Y, double last_Z)
{
    double coff = _size + 0.2;
    if(((_x+coff)>X && (_x-coff)<X) && ((_z+coff)>Z && (_z-coff)<Z) && ((_y+coff)>Y && (_y-coff)<Y))
    {
       if(!((_x+coff)>last_X && (_x-coff)<last_X)) // vérifie si en restaurant X on est toujours en collision
            return COLLISION_X;
       if(!((_y+coff)>last_Y && (_y-coff)<last_Y))
            return COLLISION_Y;
       if(!((_z+coff)>last_Z && (_z-coff)<last_Z))
            return COLLISION_Z;

        return COLLISION_XYZ; // si il y a insertion par un sommet (quasi impossible)
    }

}


Nb: COLLISION_X,... sont de simple #define COLLISION_X 5

En espérant que cela aide quelqu'un.
Hors ligne perseeverat # Posté le 04/01/2012 à 22:02:50
Avatar

Ville : Saint-benoÎt
Pays : Réunion

 Les maths c'est chaud.Il y a des subtilités qui m'échappent dans certaines formules qui sortent brusquement du bois.Mais ce n'est pas un cours de maths malheureusement (ou heureusement).
Merci c'est de l'excellent travail.
Hors ligne Ygg # Posté le 17/03/2012 à 01:06:39

Avis : Très bon

Merci Fvirtman ! J'ai pas tout lu, mais ça me sera surement très utile pour plus tard :)

Voir tous les commentaires