Lua Academy · Leçon

La boucle de jeu LOVE

load, update et draw.

Leçon 1 sur 413 étapes

La boucle de jeu LOVE est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu’est-ce que LÖVE ?

LÖVE (également écrit love2d) est un cadriciel gratuit qui vous permet de créer des jeux en 2D avec du Lua pur. Vous écrivez des fonctions de rappel que le moteur appelle à votre place.

Un jeu LÖVE se trouve dans un dossier contenant un fichier main.lua. Vous l’exécutez avec love . depuis ce dossier ; le moteur ouvre alors une fenêtre et lance la boucle.

Les trois fonctions de rappel principales

LÖVE fait fonctionner votre jeu grâce à trois fonctions de rappel que vous définissez dans main.lua : love.load, love.update et love.draw.

Vous ne les appelez pas vous-même. Le moteur appelle love.load une fois, puis répète love.update et love.draw à chaque image aussi longtemps que le jeu s’exécute.

function love.load() end
function love.update(dt) end
function love.draw() end

love.load : configuration initiale

love.load s’exécute exactement une fois au démarrage du jeu. Utilisez-le pour préparer l’état : charger les images et les polices, créer vos tables et initialiser vos variables avant le début de la boucle.

Tout ce qui est coûteux doit se produire ici, et non dans love.update ou love.draw, afin de ne pas être répété à chaque image.

function love.load()
  player = { x = 100, y = 100, speed = 200 }
  score = 0
end

love.update : logique du jeu

love.update(dt) s’exécute une fois par image et contient la logique de votre jeu : déplacer les objets, vérifier les collisions, mettre à jour les minuteurs et lire l’état des entrées.

L’argument dt représente le temps delta, c’est-à-dire le nombre de secondes écoulées depuis la dernière image. Vous ne devez jamais dessiner dans update ; gardez le dessin dans love.draw.

function love.update(dt)
  player.x = player.x + player.speed * dt
end

Pourquoi dt est important

La fréquence d’images varie selon les machines. Si vous déplaciez un objet d’une quantité fixe à chaque image, un ordinateur rapide le ferait avancer plus vite qu’un ordinateur lent.

Multiplier par dt rend le mouvement indépendant de la fréquence d’images. speed * dt signifie « unités de vitesse par seconde » : un objet parcourt donc la même distance, quel que soit le nombre d’images rendues.

-- 200 pixels per second, on any machine
player.x = player.x + 200 * dt

love.draw : rendu

love.draw s’exécute une fois par image, après love.update. Tout ce que vous voyez à l’écran est dessiné ici à l’aide du module love.graphics.

L’écran est automatiquement effacé avant chaque appel de dessin ; vous redessinez donc toute la scène à chaque image à partir de l’état actuel du jeu.

function love.draw()
  love.graphics.rectangle('fill', player.x, player.y, 32, 32)
end

La boucle complète

En réunissant les fonctions de rappel, vous obtenez un jeu complet : load prépare le joueur, update le déplace à l’aide de dt et draw l’affiche.

Ce cycle load-update-draw constitue le cœur de chaque jeu LÖVE, quelle que soit sa complexité.

function love.load() x = 0 end
function love.update(dt) x = x + 100 * dt end
function love.draw()
  love.graphics.circle('fill', x, 150, 20)
end

Lire l’horloge

Accumulez dt pour créer des minuteurs. Une méthode courante consiste à additionner le temps écoulé et à agir lorsqu’il dépasse un seuil, puis à soustraire de nouveau ce seuil.

C’est plus fiable que de compter les images, puisque leur nombre dépend du matériel, tandis que dt suit les secondes réelles.

timer = 0
function love.update(dt)
  timer = timer + dt
  if timer >= 1 then
    score = score + 1
    timer = timer - 1
  end
end

love.run et le fonctionnement interne de la boucle

En coulisses, love.run est la véritable boucle principale. Elle appelle love.load une fois, puis boucle indéfiniment : elle traite les événements, calcule dt, appelle vos fonctions update et draw, puis affiche l’image.

Vous redéfinissez rarement love.run, mais savoir qu’elle existe explique d’où viennent dt et les fonctions de rappel.

-- simplified idea of love.run
-- love.load()
-- while true do
--   dt = timer.step()
--   love.update(dt)
--   love.draw()
-- end

love.quit et le cycle de vie

LÖVE propose également des fonctions de rappel du cycle de vie en plus des trois fonctions principales. love.quit s’exécute lorsque le joueur ferme la fenêtre, ce qui vous permet de sauvegarder la progression.

Renvoyer true depuis love.quit annule la fermeture. D’autres fonctions de rappel, comme love.focus et love.resize, réagissent aux événements de la fenêtre.

function love.quit()
  print('Saving before exit...')
  return false  -- false lets the game close
end

Mettre le jeu en pause

Comme love.update pilote toute la logique, mettre le jeu en pause est simple : protégez votre logique derrière un indicateur et ignorez-la lorsqu’elle est en pause.

Le dessin continue, ce qui vous permet d’afficher une surimpression de pause. Cette séparation entre la mise à jour et le dessin explique précisément pourquoi la conception de la boucle est si flexible.

paused = false
function love.update(dt)
  if paused then return end
  player.x = player.x + player.speed * dt
end

Vérification rapide

Testez votre compréhension de la boucle de jeu de LÖVE.

Réponds-y dans la leçon interactive

Récapitulatif

LÖVE exécute votre jeu grâce à des fonctions de rappel : love.load prépare tout une fois, love.update(dt) gère la logique à chaque image et love.draw effectue le rendu à chaque image.

La valeur dt rend les mouvements indépendants de la fréquence d’images, tandis que les fonctions de rappel du cycle de vie, comme love.quit, complètent la boucle. Ce cycle fait fonctionner chaque jeu love2d.

Gratuit pour commencer

Apprends Lua avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 40
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « La boucle de jeu LOVE » est-elle gratuite ?

Oui — le texte complet de « La boucle de jeu LOVE » 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 « La boucle de jeu LOVE » ?

load, update et draw. 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 1 sur 4.

Combien de temps prend la leçon « La boucle de jeu LOVE » ?

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