Lua Academy · Aula

Script baseado em componentes

Modele entidades de jogos como tabelas com componentes de comportamento em Lua.

Script baseado em componentes é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

O que é design baseado em componentes?

Em vez de hierarquias profundas de classes, as entidades são compostas por componentes — pequenas tabelas focadas em dados e comportamento. Uma entidade é apenas uma coleção de componentes.

A entidade como tabela

Uma entidade é uma tabela com um id e uma subtabela components. Os componentes são adicionados e removidos durante a execução.

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

Adicionando componentes

Anexe um componente definindo uma chave nomeada na tabela de componentes.

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

Os sistemas processam componentes

Um sistema processa todas as entidades que têm o conjunto necessário de componentes. Os sistemas percorrem as entidades e atualizam os dados dos 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

Anexe funções Lua como comportamento de componentes — uma forma simples de criar scripts por entidade.

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

Registro de componentes

Um registro associa nomes de tipos de componentes a funções de fábrica, permitindo criar componentes pelo nome (por exemplo, a partir de um arquivo de fase).

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

Removendo componentes

Defina o componente como nil para removê-lo. A entidade será ignorada pelos sistemas que exigem esse componente.

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

Gerenciador do mundo e das entidades

Um objeto World armazena todas as entidades e os sistemas, percorre os sistemas a cada ciclo e fornece APIs para consultar entidades.

Consultando entidades por componente

Forneça uma função de consulta que retorne todas as entidades que tenham todos os 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

Prefabricados

Um prefabricado é uma tabela-modelo de componentes. Crie novas entidades a partir de prefabricados fazendo uma cópia profunda do modelo.

Vantagens em relação à herança

Não há hierarquias profundas.
O comportamento é combinado durante a execução.
É fácil adicionar ou remover recursos.
Os dados são orientados por arquivos de configuração.

Pergunta sobre design baseado em componentes

Em um design baseado em componentes, o que um sistema faz?

Recapitulação: scripts baseados em componentes

As entidades são tabelas de componentes. Os sistemas processam entidades com os componentes necessários. Essa arquitetura desacoplada e orientada por dados é mais flexível do que hierarquias profundas de herança e funciona naturalmente em Lua.

Perguntas Frequentes

A aula “Script baseado em componentes” é grátis?

Sim — o texto completo de “Script baseado em componentes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Script baseado em componentes”?

Modele entidades de jogos como tabelas com componentes de comportamento em Lua. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Script baseado em componentes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Sistemas de eventos em Lua
Script baseado em componentes
Comportamento de IA com máquinas de estados
Configuração orientada por dados e recarga a quente

← Voltar para Lua Academy