Comment optimiser le code Lua pour les jeux : 8 façons d'accélérer le jeu de 2 à 3 fois

Pourquoi l'optimisation est-elle importante dans le game dev ?

Dans les jeux, chaque image compte. Si votre code s'exécute trop longtemps, le jeu commencera à « laguer » : le FPS chutera, les animations seront saccadées et les joueurs partiront en laissant des avis négatifs. L'optimisation est particulièrement critique dans les jeux mobiles, où les ressources de l'appareil sont limitées.

La bonne nouvelle est que Lua est déjà un langage assez rapide, surtout avec le compilateur JIT LuaJIT. Mais il y a des erreurs typiques qui peuvent transformer un jeu rapide en un diaporama.

1. Les variables locales sont vos meilleures amies

Problème : les variables globales dans Lua fonctionnent plus lentement que les variables locales. Chaque fois que vous accédez à une variable globale, le moteur la recherche dans un tableau spécial.

Mauvais :

function updatePlayer()
    player.x = player.x + speed * deltaTime
    player.y = player.y + gravity * deltaTime
end

Bien :

local function updatePlayer()
    local px = player.x
    local py = player.y
    local spd = speed
    local grav = gravity
    local dt = deltaTime
    
    px = px + spd * dt
    py = py + grav * dt
    
    player.x = px
    player.y = py
end

Les variables locales sont stockées dans des registres ou dans une pile, l'accès à celles-ci est beaucoup plus rapide. Ceci est particulièrement important pour les fonctions appelées à chaque image (mise à jour, rendu).

2. Mettez en cache les résultats des calculs

Si la fonction renvoie la même valeur, ne l'appelez pas à chaque fois.

Mauvais :

function draw()
    for i = 1, #enemies do
        if distance(player, enemies[i]) < 100 then
            drawEnemy(enemies[i])
        end
    end
end

Bien :

function draw()
    local enemyCount = #enemies
    local playerX, playerY = player.x, player.y
    
    for i = 1, enemyCount do
        local enemy = enemies[i]
        local dx = enemy.x - playerX
        local dy = enemy.y - playerY
        
        if dx*dx + dy*dy < 10000 then  -- избегаем sqrt
            drawEnemy(enemy)
        end
    end
end

Ici, nous avons caché le nombre d'ennemis, les coordonnées du joueur et même évité d'appeler la fonction distance, en la remplaçant par une comparaison des carrés de distances.

3. Évitez de créer des objets dans les boucles

La création de nouveaux tableaux et de nouvelles lignes est une opération coûteuse. Le ramasse-miettes passe ensuite du temps à les nettoyer.

Mauvais :

function update()
    for i = 1, 1000 do
        local temp = {x = 0, y = 0}  -- каждый кадр 1000 новых таблиц!
        processData(temp)
    end
end

Bien :

local tempData = {x = 0, y = 0}  -- создали один раз

function update()
    for i = 1, 1000 do
        tempData.x = 0
        tempData.y = 0
        processData(tempData)
    end
end

Ou utilisez des pools d'objets pour les entités fréquemment créées (pools, particules, ennemis).

4. Travail correct avec les lignes

La concaténation de lignes via .. dans les boucles est une erreur classique.

Mauvais :

local result = ""
for i = 1, 1000 do
    result = result .. tostring(i) .. ","  -- O(n²) сложность!
end

Bien :

local parts = {}
for i = 1, 1000 do
    parts[i] = tostring(i)
end
local result = table.concat(parts, ",")  -- O(n) сложность

5. Optimisation des cycles

L'ordre de vérification des conditions est important. Mettez les conditions les plus probables en premier.

Mauvais :

for i = 1, #entities do
    if entities[i].isDead and entities[i].isVisible and entities[i].isEnemy then
        removeEntity(entities[i])
    end
end

Bien :

for i = 1, #entities do
    local entity = entities[i]
    if entity.isEnemy and entity.isVisible and entity.isDead then
        removeEntity(entity)
    end
end

Si la majorité des entités ne sont pas des ennemis, la vérification de isEnemy en premier permettra d'économiser la vérification des autres conditions.

6. Utilisez les fonctions intégrées

Les fonctions Lua intégrées sont optimisées au niveau C et fonctionnent plus rapidement que vos implémentations.

Mauvais :

function findMax(arr)
    local max = arr[1]
    for i = 2, #arr do
        if arr[i] > max then
            max = arr[i]
        end
    end
    return max
end

Bien :

local max = math.max(unpack(scores))  -- для небольших массивов

7. Profiler le code

N'optimisez pas à l'aveugle ! Utilisez des profileurs pour trouver de véritables goulots d'étranglement :

• Love2D: love.graphics.getStats() intégré

• Defold: profileur intégré

• Roblox: MicroProfiler

Il s'avère souvent que le problème n'est pas là où vous le pensiez.

8. Conseils pratiques pour les jeux

Partition spatiale

Ne vérifiez pas les collisions de tous les objets avec tous — c'est O(n²). Utilisez des quadrotrees ou des grilles.

-- Вместо:
for i = 1, #bullets do
    for j = 1, #enemies do
        checkCollision(bullets[i], enemies[j])
    end
end

-- Используйте пространственную сетку
local grid = createGrid(mapWidth, mapHeight, cellSize)
-- проверяйте коллизии только в соседних ячейках

Calculs paresseux

Ne mettez pas à jour les objets qui ne sont pas visibles à l'écran.

function updateEnemy(enemy)
    if not isOnScreen(enemy) and distanceToPlayer(enemy) > 500 then
        return  -- враг далеко и не виден — пропускаем
    end
    
    -- обычная логика обновления
end

Batching de rendu

Dessinez des objets similaires en un seul appel, si le moteur le prend en charge.

-- Вместо 100 отдельных вызовов draw:
local batch = love.graphics.newSpriteBatch(texture, 100)
for i = 1, #sprites do
    batch:add(sprites[i].quad, sprites[i].x, sprites[i].y)
end
batch:draw()

Quand ne pas optimiser

Rappelez-vous la règle : l'optimisation prématurée est la racine de tous les maux. Écrivez d'abord le code de travail, puis mesurez les performances, et seulement s'il y a des problèmes, optimisez les goulots d'étranglement.

La lisibilité du code est plus importante que les micro-optimisations. Si le jeu fonctionne à 60 FPS, il n'est pas nécessaire d'en extraire 120 FPS au prix de la lisibilité du code.

Conclusion

L'optimisation du code Lua pour les jeux est un équilibre entre performances et lisibilité. Suivez les règles simples :

• Utilisez des variables locales

• Mettez en cache les calculs

• Évitez de créer des déchets

• Profilage avant l'optimisation

• Appliquer l'optimisation algorithmique (partitionnement spatial, batching)

Grâce à ces connaissances, vos jeux fonctionneront rapidement et en douceur, même sur des appareils peu puissants !

Tout cela et bien plus encore peut être maîtrisé dans Codique — notre plateforme éducative pour les développeurs débutants. Nous créons des cours clairs sur Python, JavaScript, Lua et d'autres langages de programmation.

Et nous avons aussi cool Chaîne Telegram avec une communauté de développeurs conviviale ! Communiquez avec des personnes partageant les mêmes idées, posez des questions, partagez vos projets et obtenez des conseils de programmeurs expérimentés.

Rejoignez-nous, ensemble, apprendre est plus amusant !