Lua Academy · Leçon

Mouvements et collisions

Créez une scène jouable.

Mouvements et collisions est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Position et vitesse

Le déplacement dans LÖVE consiste à modifier la position d’un objet au fil du temps. Stockez x et y, puis ajoutez la vitesse dans love.update en la multipliant par dt.

Conserver la vitesse sous la forme de dx et dy par seconde facilite le déplacement diagonal et la physique, indépendamment de la fréquence d’affichage.

function love.update(dt)
  player.x = player.x + player.dx * dt
  player.y = player.y + player.dy * dt
end

Déplacement piloté par les entrées

Combinez l’interrogation et la vitesse pour diriger un objet. Lisez les touches de direction dans love.update, puis appliquez la vitesse multipliée par dt.

Comme love.keyboard.isDown est vérifié à chaque image, le joueur se déplace fluidement tant que la touche est maintenue.

function love.update(dt)
  if love.keyboard.isDown('left') then player.x = player.x - player.speed*dt end
  if love.keyboard.isDown('right') then player.x = player.x + player.speed*dt end
end

Normaliser la vitesse diagonale

Appuyer simultanément sur deux touches de direction accélère le déplacement diagonal, car les deux axes ajoutent chacun la vitesse maximale. Pour corriger cela, normalisez le vecteur de déplacement.

Divisez la direction par sa longueur afin que sa norme soit égale à 1, puis multipliez-la par la vitesse. Le déplacement diagonal correspond alors au déplacement en ligne droite.

local dx, dy = ix, iy
local len = math.sqrt(dx*dx + dy*dy)
if len > 0 then
  player.x = player.x + (dx/len) * player.speed * dt
end

Rester à l’intérieur de l’écran

Bornez la position afin que les objets restent à l’écran. Lisez la taille de la fenêtre avec love.graphics.getWidth et getHeight, puis limitez les coordonnées.

math.max et math.min permettent ensemble de borner proprement une valeur entre un minimum et un maximum.

local w = love.graphics.getWidth()
player.x = math.max(0, math.min(player.x, w - player.size))

Boîtes englobantes alignées sur les axes

La collision la plus simple utilise des rectangles, appelés AABB pour « boîtes englobantes alignées sur les axes ». Chaque objet possède une position x, une position y, une largeur et une hauteur.

Deux boîtes se chevauchent lorsqu’elles se croisent à la fois sur l’axe horizontal et sur l’axe vertical. Cette vérification est rapide et suffisante pour la plupart des jeux en 2D.

-- box: { x, y, w, h }

Vérifier le chevauchement des AABB

Deux rectangles se chevauchent lorsque, sur aucun des deux axes, l’un ne se trouve entièrement au-delà de l’autre. La vérification classique combine quatre comparaisons.

Si les quatre comparaisons sont vraies, les boîtes se croisent. Cette condition unique constitue l’outil principal de la détection des collisions en 2D.

function overlaps(a, b)
  return a.x < b.x + b.w and
         b.x < a.x + a.w and
         a.y < b.y + b.h and
         b.y < a.y + a.h
end

Réagir à une collision

Une fois que overlaps renvoie true, décidez de la suite : ramasser une pièce, subir des dégâts ou arrêter le déplacement. Vérifiez les collisions dans love.update après le déplacement.

Pour les objets à ramasser, supprimez simplement l’élément ou augmentez le score. Pour les murs solides, repoussez le joueur vers l’extérieur.

function love.update(dt)
  movePlayer(dt)
  if overlaps(player, coin) then
    score = score + 1
    coin.dead = true
  end
end

Collisions entre cercles

Pour les objets ronds, une collision fondée sur la distance est plus précise. Deux cercles entrent en collision lorsque la distance entre leurs centres est inférieure à la somme de leurs rayons.

Comparer les distances au carré évite le calcul coûteux de la racine carrée, une optimisation courante lorsqu’il faut vérifier de nombreux objets.

function circlesHit(a, b)
  local dx, dy = a.x - b.x, a.y - b.y
  local rsum = a.r + b.r
  return dx*dx + dy*dy < rsum*rsum
end

Résoudre les collisions avec les murs

Pour arrêter un joueur contre un mur, une approche simple consiste à le déplacer séparément sur chaque axe et à annuler le déplacement qui provoque un chevauchement.

Déplacez x, vérifiez ; s’il y a collision, restaurez x. Répétez l’opération pour y. Cette résolution séparée par axe évite de rester coincé dans les coins.

player.x = player.x + vx * dt
if overlaps(player, wall) then player.x = player.x - vx * dt end
player.y = player.y + vy * dt
if overlaps(player, wall) then player.y = player.y - vy * dt end

Appliquer la gravité

Les jeux de plateformes ajoutent une accélération constante vers le bas. Augmentez la vitesse verticale de la gravité multipliée par dt à chaque image, puis appliquez la vitesse à la position.

Lorsque le joueur atterrit au sol, mettez la vitesse verticale à zéro pour qu’il cesse de tomber. Un saut définit une vitesse verticale négative.

function love.update(dt)
  player.dy = player.dy + GRAVITY * dt
  player.y = player.y + player.dy * dt
end

Supprimer les objets détruits

Après les collisions, vous devez souvent supprimer des objets. Parcourez une liste à l’envers et appelez table.remove afin que les indices restent valides pendant la suppression.

Le parcours à l’envers est la convention Lua sûre pour supprimer des éléments au milieu d’une boucle ; il évite les éléments ignorés que provoquerait un parcours dans l’ordre.

for i = #coins, 1, -1 do
  if coins[i].dead then
    table.remove(coins, i)
  end
end

Vérification rapide

Vérifiez votre compréhension des déplacements et des collisions dans LÖVE.

Récapitulatif

Le déplacement combine la position, la vitesse et dt, avec une normalisation pour obtenir des diagonales équitables et des limites pour maintenir les objets à l’écran. Les collisions commencent par des vérifications de chevauchement AABB, complétées par des vérifications de distance pour les objets ronds.

Résolvez les collisions avec les murs en annulant les déplacements axe par axe, ajoutez la gravité pour les jeux de plateformes et supprimez les objets détruits en parcourant la liste à l’envers avec table.remove.

Questions Fréquemment Posées

La leçon « Mouvements et collisions » est-elle gratuite ?

Oui — le texte complet de « Mouvements et collisions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mouvements et collisions » ?

Créez une scène jouable. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Mouvements et collisions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Lua Academy