Scripting no Roblox para Iniciantes: Aprenda a Programar em Luau

Scripting no Roblox é como você transforma uma cena estática em um jogo jogável. Cada porta que abre, cada moeda que é coletada, cada placar que atualiza — tudo funciona com Luau, a linguagem de programação integrada ao Roblox Studio. Se você nunca escreveu uma linha de código antes, este guia vai te levar do zero até escrever scripts de jogo reais e funcionais.

Luau é baseado em Lua, mas inclui recursos modernos como verificação de tipos e otimizações de desempenho criadas especificamente para o Roblox. É uma das linguagens de programação mais amigáveis para iniciantes que existem, e tudo que você precisa para escrever e executar código já está dentro do Studio — sem necessidade de editores de código adicionais ou instalações.

Configurando Seu Ambiente de Scripting

Abra o Roblox Studio e crie um novo projeto Baseplate. Certifique-se de que você consegue ver o painel Explorer à direita e o painel Output na parte inferior — abra-os pela aba View se estiverem faltando. O Explorer é onde você cria e organiza scripts. O Output é onde você lê instruções de print e mensagens de erro — suas principais ferramentas de depuração como iniciante.

Para criar seu primeiro script, clique com o botão direito em ServerScriptService no Explorer, selecione Insert Object e escolha Script. Um novo script abre com `print("Hello world!")`. Pressione Play e verifique o painel Output — você deve ver a mensagem impressa lá. Esse é seu primeiro script bem-sucedido.

Variáveis: Armazenando Informações

Variáveis são contêineres nomeados que armazenam dados. Em Luau, você cria uma com a palavra-chave `local`: `local playerName = "Steve"` cria uma variável de texto, `local coins = 100` cria um número e `local isAlive = true` cria um booleano. Sempre use `local` — isso mantém a variável no escopo do seu bloco e evita conflitos. Use nomes descritivos como `playerHealth` em vez de `x` para que seu código continue legível.

Os tipos de dados principais do Luau são `string` para texto, `number` para inteiros e decimais, `boolean` para verdadeiro/falso, `nil` para ausência de valor e `table` para coleções. Você não declara tipos — Luau os infere automaticamente. Concatene strings com `..` como `"Hello, " .. playerName`, converta entre tipos com `tostring()` e `tonumber()`, e use strings com crase e chaves para interpolação.

Funções: Blocos de Código Reutilizáveis

Uma função é um bloco de código nomeado que executa quando você o chama. A estrutura é `local function giveCoins(player, amount)` seguida do corpo e `end`. As palavras entre parênteses são parâmetros — entradas que a função recebe. Chame com `giveCoins(somePlayer, 50)`. Funções também podem retornar valores: `local damage = calculateDamage(50, 20)` captura o resultado retornado.

Acostume-se a escrever funções pequenas desde cedo. Todo sistema de jogo — combate, inventário, lojas, placares — é organizado em funções. Se um bloco de código faz uma coisa específica, envolva-o em uma função e dê um nome claro.

If/Else: Tomando Decisões

A instrução `if` avalia uma condição e executa o código apenas quando é verdadeira. A sintaxe é `if coins >= 100 then` seguida do seu código, opcionalmente `elseif` para condições adicionais, `else` para um fallback e `end` para fechar. Os operadores de comparação incluem `==` para igualdade, `~=` para desigualdade, `>`, `<`, `>=` e `<=`. Combine condições com `and`, `or` e `not` — por exemplo, `if isAlive and coins > 0 then` só executa quando ambas são verdadeiras.

Um erro comum de iniciante é usar `=` em vez de `==` para comparação. Um único `=` atribui um valor. Dois `==` comparam dois valores. Se seu script se comportar de forma inesperada, verifique isso primeiro.

Loops: Repetindo Ações

O loop `for` executa um número definido de vezes. Escreva `for i = 1, 10 do` seguido do código e `end` para executar dez vezes. Adicione um valor de passo — `for i = 10, 1, -1 do` conta de trás para frente. O loop `while` executa enquanto uma condição for verdadeira, mas precisa de `task.wait()` dentro para evitar travamentos.

O loop `for` genérico itera sobre coleções. Use `for index, value in ipairs(myTable) do` para listas ordenadas, ou `for key, value in pairs(myDictionary) do` para dicionários chave-valor. É assim que você processa inventários, listas de jogadores e dados de placar.

Tables: Organizando Dados

Tables são a estrutura de dados mais versátil do Luau — arrays, dicionários ou ambos. Crie um array com `local fruits = {"Apple", "Banana", "Cherry"}` e acesse itens com `fruits[1]` (Luau começa em 1, não em 0). Crie um dicionário com `local playerData = {coins = 100, level = 5}` e acesse valores com `playerData.coins`. Praticamente todo sistema de jogo armazena dados em tables.

Eventos: Respondendo ao Mundo do Jogo

Eventos são a espinha dorsal do scripting no Roblox. Em vez de verificar constantemente se algo aconteceu, você conecta uma função a um evento e o Roblox a chama automaticamente quando ele dispara. O evento de iniciante mais comum é o `Touched` — conecte com `part.Touched:Connect(function(hit) end)` onde `hit` é a parte que colidiu. Outros essenciais incluem `PlayerAdded` (dispara quando um jogador entra), `PlayerRemoving` (dispara quando um jogador sai), `CharacterAdded` (dispara quando um personagem surge) e `Changed` (dispara quando uma propriedade é atualizada). Armazene conexões em variáveis e chame `connection:Disconnect()` quando não forem mais necessárias para evitar vazamentos de memória.

Server Scripts vs. Local Scripts

Server Scripts rodam no servidor do Roblox e controlam a lógica autoritativa do jogo — conceder moedas, salvar dados, gerenciar rodadas. Coloque-os no ServerScriptService. Local Scripts rodam no dispositivo de cada jogador para tarefas específicas do cliente — câmera, entrada, interface. Coloque-os em StarterPlayerScripts, StarterCharacterScripts ou StarterGui.

A regra de ouro: nunca confie no cliente. Qualquer lógica que afete a jogabilidade deve acontecer no servidor. O cliente envia solicitações via RemoteEvents no ReplicatedStorage — dispare do cliente com `remoteEvent:FireServer(data)`, escute no servidor com `remoteEvent.OnServerEvent:Connect(function(player, data) end)`. O servidor valida e executa.

Seu Primeiro Script de Jogo: Um Kill Brick

Insira uma Part no Workspace e pinte de vermelho. Clique com o botão direito nela no Explorer, insira um Script e substitua o código padrão. Escreva `local killPart = script.Parent` para referenciar a peça. Defina `local function onTouched(hit)` e dentro escreva `local humanoid = hit.Parent:FindFirstChild("Humanoid")` seguido de `if humanoid then humanoid.Health = 0 end`. Conecte com `killPart.Touched:Connect(onTouched)`.

Pressione Play e caminhe até a peça vermelha. Seu personagem morre e renasce. Esse é um script de jogo completo em sete linhas — todo obby no Roblox usa exatamente esse padrão para blocos de perigo.

Seu Segundo Script: Um Sistema de Coleta de Moedas

Crie uma Part cilíndrica amarela e insira um Script. Escreva `local coin = script.Parent` e `local debounce = false`. Na função `onTouched`, verifique `if debounce then return end`, defina `debounce = true`, confirme que um Humanoid existe, então esconda a moeda com `coin.Transparency = 1` e `coin.CanCollide = false`. Após `task.wait(5)`, restaure-a e redefina o debounce. O padrão de debounce aparece em quase todo script Touched — sem ele, o evento dispara dezenas de vezes por segundo enquanto as peças se sobrepõem, causando coletas duplicadas. Domine o debouncing desde cedo.

Seu Terceiro Script: Uma Porta que Abre

Crie uma Part alta e fina para uma porta. Armazene `local door = script.Parent` e `local originalPosition = door.Position`. Ao tocar, mova-a para cima com `door.Position = originalPosition + Vector3.new(0, 10, 0)`, espere com `task.wait(3)` e então redefina. Isso apresenta o `Vector3` — o tipo de dado para posições 3D onde y é para cima no Roblox. Para movimentos mais suaves, use TweenService: obtenha com `game:GetService("TweenService")`, crie um TweenInfo para duração e chame `tweenService:Create(door, tweenInfo, {Position = targetPosition}):Play()`. Tweens animam qualquer propriedade ao longo do tempo e fazem as interações parecerem polidas.

Serviços Essenciais do Roblox

Acesse qualquer serviço com `game:GetService("ServiceName")` e armazene a referência no topo do seu script. Confira o guia de ferramentas de scripting para mais recursos sobre como trabalhar com a API completa do Roblox.

Erros Comuns e Mensagens de Erro

Colocar um LocalScript no ServerScriptService. LocalScripts só rodam em contêineres do cliente — StarterPlayerScripts, StarterCharacterScripts ou sob uma GUI no StarterGui. Se seu código do cliente não faz nada, verifique a localização primeiro.

Esquecer de verificar nil. Se `FindFirstChild` retornar `nil` e você acessar uma propriedade nele, seu script quebra com "attempt to index nil." Sempre envolva buscas em uma verificação if antes de usar o resultado.

Usar wait() em vez de task.wait(). O `wait()` legado é impreciso e obsoleto. Use `task.wait(seconds)` para atrasos, `task.spawn()` para threads e `task.delay()` para chamadas adiadas.

Quando erros aparecem no painel Output, leia-os com atenção — eles incluem o nome do script, o número da linha e a descrição. O erro "expected 'end'" significa um bloco não fechado. Conte seus pares de `if/then/end` e `function/end` — cada palavra-chave de abertura precisa de um `end` correspondente.

Salvando Dados do Jogador

DataStoreService salva o progresso do jogador entre sessões. Obtenha um armazenamento com `game:GetService("DataStoreService"):GetDataStore("PlayerData")`. Carregue ao entrar com `pcall(function() return dataStore:GetAsync("Player_" .. player.UserId) end)` e salve ao sair com `SetAsync`. Sempre envolva chamadas de data store em `pcall` para capturar erros de rede que, de outra forma, quebrariam seu script. Salve em `PlayerRemoving` e considere um salvamento automático com timer como backup. Data stores requerem um jogo publicado — habilite o acesso à API nas configurações do jogo para testes no Studio. Perda de dados é a forma mais rápida de perder jogadores permanentemente.

Próximos Passos

Desempenho importa desde o primeiro dia. Conforme os scripts crescem, maus hábitos se acumulam. Leia nosso guia sobre desempenho de jogos para entender como as escolhas de scripting afetam a taxa de quadros, memória e tráfego de rede.

A melhor forma de aprender é construindo. Escolha um projeto pequeno — um coletor de moedas, um obby com placar, um quebra-cabeça de portas — e construa do zero. Quando travar, leia o painel Output, pesquise na documentação do Roblox e itere. Scripting no Roblox é um dos pontos de entrada mais recompensadores na programação porque o ciclo de feedback é imediato: escreva código, pressione Play, veja o resultado.