Cómo optimizar el código Lua para juegos: 8 formas de acelerar el juego 2-3 veces

¿Por qué es importante la optimización en el desarrollo de juegos?

En los juegos, cada fotograma cuenta. Si tu código se ejecuta durante demasiado tiempo, el juego comenzará a «tirarse» — el FPS caerá, las animaciones se sacudirán y los jugadores se irán a escribir reseñas negativas. La optimización es especialmente crítica en los juegos para móviles, donde los recursos del dispositivo son limitados.

La buena noticia es que Lua ya es un lenguaje bastante rápido, especialmente con el compilador JIT LuaJIT. Pero hay errores típicos que pueden convertir un juego rápido en una presentación de diapositivas.

1. Las variables locales son tu mejor amigo

Problema: las variables globales en Lua funcionan más lentamente que las locales. Cada vez que se accede a una variable global, el motor la busca en una tabla especial.

Mal:

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

Las variables locales se almacenan en registros o en una pila, el acceso a ellas es mucho más rápido. Esto es especialmente importante para las funciones que se llaman en cada cuadro (actualizar, renderizar).

2. Almacena en caché los resultados de los cálculos

Si la función devuelve el mismo valor, no la vuelvas a llamar cada vez.

Mal:

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

Aquí hemos marcado el número de enemigos, las coordenadas del jugador e incluso hemos evitado llamar a la función distance, reemplazándola por una comparación de cuadrados de distancia.

3. Evita crear objetos en bucles

Crear nuevas tablas y filas es una operación costosa. El recolector de basura luego pasa tiempo limpiándolas.

Mal:

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

O utiliza grupos de objetos para entidades creadas con frecuencia (balas, partículas, enemigos).

4. Trabajo correcto con las líneas

La concatenación de cadenas a través de .. en bucles es un error clásico.

Mal:

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. Optimización de ciclos

El orden de verificación de las condiciones es importante. Pon las condiciones más probables primero.

Mal:

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 mayoría de las entidades no son enemigos, la comprobación de isEnemy primero ahorrará la comprobación de las condiciones restantes.

6. Utiliza las funciones integradas

Las funciones Lua integradas están optimizadas a nivel de C y funcionan más rápido que tus implementaciones.

Mal:

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. Perfila el código

¡No optimices a ciegas! Utiliza los perfiladores para encontrar los cuellos de botella reales:

• Love2D: love.graphics.getStats() integrado

• Defold: perfilador integrado

• Roblox: MicroProfiler

A menudo resulta que el problema no está donde pensabas.

8. Consejos prácticos para los juegos

Partición espacial

No compruebes las colisiones de todos los objetos con todos: esto es O(n²). Utiliza cuadros o cuadrículas.

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

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

Cálculos perezosos

No actualizar los objetos que no son visibles en la pantalla.

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

Procesamiento por lotes de renderizado

Dibuja objetos similares con una sola llamada, si el motor lo admite.

-- Вместо 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()

Cuándo no se debe optimizar

Recuerda la regla: la optimización prematura es la raíz de todos los malesPrimero, escribe el código que funciona, luego mide el rendimiento y solo si hay problemas, optimiza los cuellos de botella.

La legibilidad del código es más importante que las microoptimizaciones. Si el juego funciona a 60 FPS, no es necesario exprimirlo a 120 FPS a costa de la claridad del código.

Conclusión

La optimización del código Lua para juegos es un equilibrio entre rendimiento y legibilidad. Sigue unas reglas sencillas:

• Utilice variables locales

• Almacenar en caché los cálculos

• Evite generar residuos

• Perfila antes de optimizar

• Aplicar optimización algorítmica (partición espacial, agrupamiento)

¡Con estos conocimientos, tus juegos funcionarán de forma rápida y fluida incluso en dispositivos débiles!

Todo esto y mucho más se puede aprender en Codice — nuestra plataforma educativa para desarrolladores principiantes. Creamos cursos comprensibles en Python, JavaScript, Lua y otros lenguajes de programación.

Y también tenemos genial Canal de Telegram ¡con una comunidad de desarrolladores amigable! Comunícate con personas de ideas afines, haz preguntas, comparte tus proyectos y recibe consejos de programadores experimentados.

¡Únete a nosotros, juntos aprenderemos más divertido!