0Pricing
Lua Academy · Lección

Scripting basado en componentes

Diseñe entidades de juego como tablas con componentes de comportamiento en Lua.

Scripting basado en componentes es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 2 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.

¿Qué es el diseño basado en componentes?

En lugar de jerarquías profundas de clases, las entidades se componen de componentes: tablas pequeñas y especializadas que contienen datos y comportamiento. Una entidad es simplemente un conjunto de componentes.

La entidad como tabla

Una entidad es una tabla con un id y una subtabla components. Los componentes se añaden y eliminan durante la ejecución.

local function newEntity(id)
  return {id = id, components = {}}
end
local player = newEntity(1)

Añadir componentes

Asocie un componente estableciendo una clave con nombre en la tabla de componentes.

player.components.position = {x=0, y=0}
player.components.health   = {hp=100, max=100}
player.components.sprite   = {image="player.png", scale=1}

Los sistemas procesan componentes

Un sistema procesa todas las entidades que tienen el conjunto de componentes requerido. Los sistemas iteran sobre las entidades y actualizan los datos de sus componentes.

local function moveSystem(entities, dt)
  for _, e in ipairs(entities) do
    local pos = e.components.position
    local vel = e.components.velocity
    if pos and vel then
      pos.x = pos.x + vel.dx * dt
      pos.y = pos.y + vel.dy * dt
    end
  end
end

Scripts de componentes

Asocie funciones de Lua como comportamiento de los componentes: una forma sencilla de crear scripts específicos para cada entidad.

player.components.ai = {
  update = function(self, entity, dt)
    -- move towards target
  end
}

Registro de componentes

Un registro asigna nombres de tipos de componentes a funciones de fábrica, lo que permite crear componentes por nombre (por ejemplo, desde un archivo de nivel).

local registry = {}
function registry.register(name, factory)
  registry[name] = factory
end
function registry.create(name, ...)
  return registry[name](...)
end

Eliminar componentes

Establezca el componente en nil para eliminarlo. La entidad será ignorada por los sistemas que lo requieran.

player.components.health = nil  -- entity is "dead"

Gestor del mundo y de entidades

Un objeto World almacena todas las entidades y los sistemas, itera sobre los sistemas en cada tick y proporciona APIs para consultar entidades.

Consultar entidades por componente

Proporcione una función de consulta que devuelva todas las entidades que tengan todos los componentes especificados.

local function query(world, ...)
  local required = {...}
  local result = {}
  for _, e in ipairs(world.entities) do
    local ok = true
    for _, comp in ipairs(required) do
      if not e.components[comp] then ok = false; break end
    end
    if ok then result[#result+1] = e end
  end
  return result
end

Prefabs

Un prefab es una tabla plantilla de componentes. Cree instancias de nuevas entidades a partir de prefabs copiando la plantilla en profundidad.

Ventajas frente a la herencia

  • Sin jerarquías profundas.
  • El comportamiento se combina durante la ejecución.
  • Es fácil añadir y eliminar funcionalidades.
  • Los datos se basan en archivos de configuración.

Pregunta sobre el diseño basado en componentes

En el diseño basado en componentes, ¿qué hace un System?

Resumen: scripting basado en componentes

Las entidades son tablas de componentes. Los sistemas procesan las entidades que tienen los componentes requeridos. Esta arquitectura desacoplada y basada en datos es más flexible que las jerarquías profundas de herencia y funciona de forma natural en Lua.

Preguntas frecuentes

¿La lección «Scripting basado en componentes» es gratis?

Sí — el texto completo de «Scripting basado en componentes» 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 «Scripting basado en componentes»?

Diseñe entidades de juego como tablas con componentes de comportamiento en Lua. 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 2 de 4.

¿Cuánto tiempo toma la lección «Scripting basado en componentes»?

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

  1. Sistemas de eventos en Lua
  2. Scripting basado en componentes
  3. Comportamiento de IA con máquinas de estados
  4. Configuración basada en datos y hot-reload
← Volver a Lua Academy