La Détection de Collisions dans les Jeux Vidéo : AABB, Cercles et Bonnes Pratiques

Apprenez comment les jeux vidéo détectent les collisions : boîtes AABB, cercles, hitbox, phase large et phase fine, avec exemples de code simples.

Partager sur Linkedin Partager sur WhatsApp

Temps de lecture estimé : 8 minutes

Image de l'article La Détection de Collisions dans les Jeux Vidéo : AABB, Cercles et Bonnes Pratiques

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

FormeAvantagesInconvénientsUsage typique
AABBTrès rapide, facile à coderImprécis pour les objets qui tournent ou de forme irrégulièrePlateformes, tuiles, interfaces
Cercle / sphèreRapide, indépendant de la rotationPeu adapté aux objets allongésProjectiles, personnages vus de dessus
Boîte orientée (OBB)Suit la rotation de l’objetCalcul plus complexeVéhicules, objets qui pivotent
Polygone / maillageGrande précisionCoûteux en calculDé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 :

  1. 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).
  2. 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.

Flexbox ou CSS Grid : Quand Utiliser l’Un ou l’Autre

Flexbox gère une dimension, Grid en gère deux. Comprenez la différence, les propriétés clés et comment combiner les deux dans un vrai projet.

RECHERCHEV et RECHERCHEX : Retrouver une Donnée dans un Tableau Excel

Apprenez à utiliser RECHERCHEV et RECHERCHEX dans Excel : syntaxe, différences, erreurs fréquentes et astuces pour des recherches fiables.

Comment un Modèle de Langage Génère du Texte : Tokens, Probabilités et Contexte

Découvrez comment fonctionne un modèle de langage : découpage en tokens, prédiction du mot suivant, fenêtre de contexte, hallucinations et bonnes pratiques.

Mémoire Virtuelle et Fichier d’Échange : Ce Qui Se Passe Quand la RAM Est Pleine

Comment un système d’exploitation fait tenir plus de programmes que la RAM ne peut en contenir, et pourquoi la machine ralentit.

Qu’est-ce qu’une API REST ? Le langage commun des applications

Comprendre les API REST : ressources, méthodes HTTP, codes de statut et bonnes pratiques, expliqués simplement.

Clés Primaires et Clés Étrangères : Comprendre les Relations entre Tables

Clé primaire, clé étrangère, intégrité référentielle : les notions de base pour organiser correctement une base de données relationnelle.

Git et le Contrôle de Version : Comprendre les Bases

Découvrez à quoi sert un système de contrôle de version, les commandes essentielles de Git et les bonnes pratiques pour travailler en équipe.

Qu’est-ce que le phishing et comment s’en protéger ?

Découvrez ce qu’est le phishing, comment reconnaître ces tentatives d’arnaque en ligne et quels réflexes adopter pour protéger vos données.