Un personnage qui atterrit sur une plateforme, une balle qui touche un ennemi, une pièce ramassée au passage : derrière chacune de ces actions se cache une question que le jeu se pose des dizaines de fois par seconde — « ces deux objets se touchent-ils ? ». C’est le rôle de la détection de collisions, l’un des piliers de la programmation de jeux vidéo. Sans elle, les personnages traverseraient les murs et les projectiles passeraient à travers leurs cibles.
Dans cet article, vous découvrirez les techniques les plus courantes, avec des exemples simples à comprendre et à reproduire.
Détection et réponse : deux étapes distinctes
Lorsqu’on parle de collisions, il faut séparer deux problèmes :
- La détection : savoir si deux objets se chevauchent (et parfois où, et de combien).
- La réponse : décider ce qui se passe ensuite. Le joueur est repoussé hors du mur, l’ennemi perd des points de vie, la pièce disparaît et le score augmente.
Cet article se concentre surtout sur la détection, qui est la base de tout le reste.
La hitbox : une forme simple pour un objet complexe
Tester la collision pixel par pixel entre deux images détaillées serait coûteux en calculs. Les jeux utilisent donc des formes géométriques simplifiées qui entourent les objets : on les appelle hitbox (ou boîtes de collision). Un personnage dessiné avec beaucoup de détails peut ainsi être représenté, pour la physique, par un simple rectangle ou un cercle. Le joueur ne voit pas la hitbox, mais c’est elle qui décide si un coup touche ou non.
Technique 1 : les boîtes AABB
AABB signifie Axis-Aligned Bounding Box, c’est-à-dire une boîte englobante alignée sur les axes. Il s’agit d’un rectangle (ou d’un pavé en 3D) dont les côtés restent parallèles aux axes X et Y : il ne tourne jamais. C’est la technique la plus utilisée dans les jeux 2D, notamment les jeux de plateforme.
Deux rectangles A et B (définis par leur position x, y, leur largeur et leur hauteur) se chevauchent si les quatre conditions suivantes sont vraies en même temps :
function collisionAABB(a, b) {
return a.x < b.x + b.largeur &&
a.x + a.largeur > b.x &&
a.y < b.y + b.hauteur &&
a.y + a.hauteur > b.y;
}
L’idée est simple : deux rectangles ne se touchent pas si l’un est entièrement à gauche, à droite, au-dessus ou au-dessous de l’autre. Si aucune de ces situations n’est vraie, ils se chevauchent forcément. Ce test ne demande que quelques comparaisons : il est extrêmement rapide.
Technique 2 : les cercles
Pour les objets ronds — balles, astéroïdes, personnages vus de dessus — on utilise des cercles. Deux cercles se touchent si la distance entre leurs centres est inférieure ou égale à la somme de leurs rayons.
function collisionCercles(c1, c2) {
const dx = c2.x - c1.x;
const dy = c2.y - c1.y;
const sommeRayons = c1.rayon + c2.rayon;
return dx * dx + dy * dy <= sommeRayons * sommeRayons;
}
Remarquez l’astuce : au lieu de calculer la racine carrée (théorème de Pythagore), on compare directement les distances au carré. Le résultat est identique et le calcul plus léger, ce qui compte quand on teste des centaines d’objets à chaque image.
Comparer les formes de collision
| Forme | Avantages | Inconvénients | Usage typique |
|---|---|---|---|
| AABB | Très rapide, facile à coder | Imprécis pour les objets qui tournent ou de forme irrégulière | Plateformes, tuiles, interfaces |
| Cercle / sphère | Rapide, indépendant de la rotation | Peu adapté aux objets allongés | Projectiles, personnages vus de dessus |
| Boîte orientée (OBB) | Suit la rotation de l’objet | Calcul plus complexe | Véhicules, objets qui pivotent |
| Polygone / maillage | Grande précision | Coûteux en calcul | Décors complexes, physique avancée |
Phase large et phase fine : tester intelligemment
Imaginez un jeu avec 500 objets. Tester chaque paire signifierait environ 125 000 tests par image : c’est beaucoup trop. Les moteurs de jeu divisent donc le travail en deux étapes :
- Phase large (broad phase) : on élimine rapidement les paires d’objets trop éloignés pour se toucher. On utilise pour cela des structures qui découpent l’espace, comme une grille (chaque objet n’est comparé qu’à ceux de sa cellule et des cellules voisines) ou un quadtree (qui subdivise l’espace en quatre zones, récursivement).
- Phase fine (narrow phase) : on applique les tests précis (AABB, cercles, polygones) uniquement aux paires restantes.
Cette approche permet de garder un jeu fluide même avec beaucoup d’éléments à l’écran.
Un piège classique : l’effet tunnel
Le jeu ne vérifie les collisions qu’à des instants précis, une fois par image. Si un objet se déplace très vite — une balle de fusil, par exemple — il peut se trouver devant un mur à une image et derrière lui à l’image suivante, sans qu’aucun chevauchement ne soit jamais détecté. C’est ce qu’on appelle l’effet tunnel (tunneling).
Pour l’éviter, on peut limiter la vitesse maximale, diviser le mouvement en plusieurs petits pas, ou utiliser la détection continue, qui calcule la trajectoire entre deux positions (par exemple avec un lancer de rayon, ou raycast).
Bonnes pratiques pour débuter
- Affichez les hitbox pendant le développement : dessiner les contours de collision aide énormément à trouver les bugs.
- Faites des hitbox un peu plus petites que le sprite pour le joueur : cela rend le jeu plus « juste » et agréable à jouer.
- Séparez la logique de collision du rendu graphique : le code reste plus clair et plus facile à maintenir.
- Profitez des outils de votre moteur : Unity, Godot ou Unreal Engine intègrent des systèmes de collision complets. Comprendre les principes vous aidera à mieux les configurer.
Conclusion
La détection de collisions repose sur une idée simple — représenter les objets par des formes géométriques faciles à tester — et sur quelques astuces d’optimisation. En maîtrisant les AABB, les cercles et la distinction entre phase large et phase fine, vous avez déjà en main les bases utilisées dans une grande partie des jeux 2D.
Pour passer de la théorie à la pratique, explorez les cours gratuits de programmation de jeux disponibles sur Cursa et créez vos premiers prototypes jouables.















