Lua Academy · Lección

Movimiento y colisiones

Cree una escena jugable

Movimiento y colisiones es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Posición y velocidad

El movimiento en LÖVE consiste en cambiar la posición de un objeto con el paso del tiempo. Guarde x e y y, después, sume la velocidad en love.update, escalada mediante dt.

Mantener la velocidad como dx y dy por segundo simplifica el movimiento diagonal y la física, además de hacerlos independientes de la frecuencia de los fotogramas.

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

Movimiento controlado por la entrada

Combine el sondeo con la velocidad para dirigir un objeto. Lea las teclas de dirección en love.update y aplique la velocidad multiplicada por dt.

Como love.keyboard.isDown se comprueba en cada fotograma, el jugador se mueve suavemente mientras se mantiene pulsada la tecla.

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

Normalizar la velocidad diagonal

Al pulsar dos teclas de dirección a la vez, el movimiento diagonal se vuelve más rápido, ya que ambos ejes suman la velocidad completa. Para corregirlo, normalice el vector de movimiento.

Divida la dirección por su longitud para que su magnitud sea 1 y, después, multiplíquela por la velocidad. Así, el desplazamiento diagonal coincide con el desplazamiento en línea recta.

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

Mantenerse dentro de la pantalla

Limite la posición para que los objetos permanezcan en pantalla. Lea el tamaño de la ventana con love.graphics.getWidth y getHeight y, después, acote las coordenadas.

math.max y math.min juntas limitan un valor entre un mínimo y un máximo de forma sencilla.

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

Cajas delimitadoras alineadas con los ejes

La colisión más sencilla utiliza rectángulos, llamados AABB por sus siglas en inglés. Cada objeto tiene x, y, anchura y altura.

Dos cajas se solapan cuando se intersectan simultáneamente en los ejes horizontal y vertical. Esta comprobación es rápida y suficiente para la mayoría de los juegos 2D.

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

Prueba de solapamiento AABB

Dos rectángulos se solapan cuando el borde izquierdo de cada uno queda antes que el borde derecho del otro y sus bordes superiores e inferiores también se superponen. La prueba clásica combina cuatro comparaciones.

Si las cuatro son verdaderas, las cajas se intersectan. Esta única condición es la base de la detección de colisiones en juegos 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

Responder a una colisión

Cuando overlaps devuelve true, decida qué sucede: recoger una moneda, recibir daño o detener el movimiento. Compruebe las colisiones en love.update después de mover los objetos.

Para los objetos que se recogen, simplemente elimine el objeto o incremente la puntuación. Para las paredes sólidas, vuelva a empujar al jugador hacia fuera.

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

Colisiones entre círculos

Para los objetos redondos, la colisión basada en la distancia es más precisa. Dos círculos colisionan cuando la distancia entre sus centros es menor que la suma de sus radios.

Comparar las distancias al cuadrado evita la costosa raíz cuadrada, una optimización habitual al comprobar muchos objetos.

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

Resolver colisiones con paredes

Para detener a un jugador contra una pared, un método sencillo consiste en moverlo por cada eje por separado y deshacer el paso que provoque un solapamiento.

Mueva x y compruebe; si colisiona, revierta x. Repita el proceso con y. Esta resolución por ejes separados evita que el jugador se quede atascado en las esquinas.

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

Aplicar gravedad

Los juegos de plataformas añaden una aceleración constante hacia abajo. Incremente la velocidad vertical en gravedad multiplicada por dt en cada fotograma y, después, aplique la velocidad a la posición.

Cuando el jugador aterrice en el suelo, establezca la velocidad vertical en cero para que deje de caer. Saltar establece una velocidad vertical negativa.

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

Eliminar objetos muertos

Después de las colisiones, a menudo tendrá que eliminar objetos. Recorra una lista hacia atrás y llame a table.remove para que los índices sigan siendo válidos durante la eliminación.

Recorrer hacia atrás es la convención segura de Lua para eliminar elementos durante un bucle y evita que se omitan entradas, como ocurriría al recorrer hacia delante.

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

Comprobación rápida

Compruebe su comprensión del movimiento y las colisiones en LÖVE.

Repaso

El movimiento combina posición, velocidad y dt, con normalización para obtener diagonales equilibradas y limitación para mantener los objetos en pantalla. Las colisiones comienzan con pruebas de solapamiento AABB, complementadas con comprobaciones de distancia para los objetos circulares.

Resuelva las colisiones con paredes revirtiendo los movimientos por eje, añada gravedad para los juegos de plataformas y elimine los objetos inactivos recorriendo la lista hacia atrás con table.remove.

Preguntas frecuentes

¿La lección «Movimiento y colisiones» es gratis?

Sí — el texto completo de «Movimiento y colisiones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Movimiento y colisiones»?

Cree una escena jugable Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Movimiento y colisiones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy