LµĀap³ p Scäáøì j¾ R¾b«¾ĝ:
D¾³µaµj¾ a Pä¾äa³afã¾ jp
J¾¾ì
Bem-vindo ao mundo da programação de jogos no Roblox! Este curso guiará você desde
os conceitos fundamentais até técnicas avançadas, capacitando-o a criar experiências
interativas para milhões de jogadores. No coração da programação Roblox está a
linguagem Lua, conhecida por sua leveza, eficiência e facilidade de aprendizado, perfeita
para dar vida a objetos, personagens e interações dinâmicas.
Você aprenderá desde a sintaxe básica de Lua, manipulação de objetos, criação de
eventos e funções, até interfaces de usuário (GUIs) e armazenamento de dados. O curso
capacitará você com técnicas essenciais para desenvolver mecânicas de jogo
sofisticadas no ambiente integrado do Roblox Studio.
Dominar a programação no Roblox abre portas para inúmeras oportunidades criativas e
profissionais, permitindo que você construa mundos virtuais inovadores ou monetize
suas criações para uma audiência global. Este curso é o seu primeiro passo essencial
para um potencial ilimitado.
Por que aprender Lua no Roblox?
Lua é uma linguagem de programação poderosa, leve e fácil de aprender,
escolhida pelo Roblox como sua linguagem principal de script. Com mais
de 200 milhões de usuários ativos mensais, o Roblox oferece uma
plataforma extraordinária para desenvolvedores iniciantes e experientes.
Aprender Lua no contexto do Roblox não apenas ensina programação de
forma prática e divertida, mas também abre portas para oportunidades
reais de monetização. Desenvolvedores bem-sucedidos ganham milhões
através da criação de jogos populares, transformando criatividade em
carreira profissional.
Visão geral da plataforma Roblox
O Roblox é muito mais que uma plataforma de jogos - é um universo completo de criação e compartilhamento de experiências interativas. Fundado em
2006, evoluiu para se tornar uma das maiores plataformas de entretenimento digital do mundo, onde jogadores se tornam criadores.
Comunidade Global
Milhões de desenvolvedores e jogadores
conectados diariamente
Ferramentas Gratuitas
Roblox Studio oferece tudo necessário para
criar jogos completos
Monetização Real
Ganhe Robux e converta em dinheiro real
através de seus jogos

Scripts são os cérebros por trás de cada jogo no Roblox. Eles controlam tudo: desde o movimento de personagens até sistemas complexos de inventário,
física de objetos e interações entre jogadores. Sem scripts, seu jogo seria apenas um cenário estático e sem vida.
Pense nos scripts como instruções detalhadas que você dá ao computador. Quando um jogador pressiona um botão, pula ou interage com um objeto, é o
script que determina exatamente o que acontece. Dominar scripts significa ter controle total sobre a experiência que você cria.
No Roblox, scripts são escritos em Lua e armazenados como objetos especiais dentro do seu jogo, podendo ser anexados a praticamente qualquer
elemento do ambiente virtual.
Dpäpµfaì pµøäp SpäėpäScäáø p L¾ca«Scäáø
SpäėpäScäáø
Executado no servidor do Roblox, garantindo segurança e
sincronização entre todos os jogadores. Ideal para lógica de jogo
crítica, sistemas de pontuação, gerenciamento de dados e eventos
que afetam múltiplos jogadores simultaneamente.
Visível e afeta todos os jogadores
Não pode ser manipulado por exploiters
Usado para mecânicas principais do jogo
L¾ca«Scäáø
Executado no computador do jogador individual, proporcionando
responsividade instantânea e reduzindo latência. Perfeito para
interfaces de usuário, efeitos visuais locais, controles de câmera e
feedback imediato às ações do jogador.
Afeta apenas o jogador local
Melhor performance para UI e efeitos
Vulnerável a exploits se mal utilizado
Compreender quando usar cada tipo de script é fundamental para criar jogos seguros, performáticos e envolventes no Roblox.
Introdução à linguagem Lua
Lua é uma linguagem de script elegante, criada no Brasil em 1993 por pesquisadores da
PUC-Rio. Seu nome significa "lua" em português, refletindo suas origens brasileiras. É
conhecida por ser simples, rápida e extremamente versátil.
Diferente de linguagens mais complexas, Lua foi projetada para ser embutida em
aplicações, tornando-a perfeita para o Roblox. Sua sintaxe limpa e intuitiva permite que
iniciantes comecem a programar rapidamente, enquanto oferece recursos poderosos
para desenvolvedores avançados.
Lua é utilizada em inúmeros jogos famosos além do Roblox, incluindo World of Warcraft,
Angry Birds e Civilization, comprovando sua eficácia e confiabilidade na indústria de
games.

Variáveis são containers que armazenam informações em seus scripts. Em Lua, criar uma variável é extremamente simples - basta dar um nome e
atribuir um valor. Não é necessário declarar o tipo de dado antecipadamente, tornando a linguagem flexível e fácil de usar.
-- Tipos de dados básicos
local nome = "João" -- String (texto)
local idade = 15 -- Number (número inteiro)
local altura = 1.75 -- Number (decimal)
local jogando = true -- Boolean (verdadeiro/falso)
local inventario = nil -- Nil (valor vazio)
Strings
Representam texto, sempre entre aspas simples ou duplas
Numbers
Representam números inteiros ou decimais, sem distinção
Booleans
Representam verdadeiro (true) ou falso (false)
Nil
Representa a ausência de valor ou variável não inicializada

local a = 10
local b = 3
print(a + b) -- 13 (adição)
print(a - b) -- 7 (subtração)
print(a * b) -- 30 (multiplicação)
print(a / b) -- 3.33 (divisão)
print(a % b) -- 1 (módulo/resto)
print(a ^ b) -- 1000 (exponenciação)

local x = true
local y = false
print(x and y) -- false
print(x or y) -- true
print(not x) -- false
-- Comparações
print(10 > 5) -- true
print(10 == 5) -- false
print(10 ~= 5) -- true (diferente)
print(10 >= 10) -- true

Operadores são ferramentas essenciais que permitem realizar cálculos, comparações e tomar decisões em seus scripts. Dominar esses conceitos é
fundamental para criar lógica de jogo complexa e sistemas interativos sofisticados.
EìøäĀøĀäaì c¾µjc¾µaì: , p«ìp p
p«ìp
Estruturas condicionais permitem que seu código tome decisões baseadas em
diferentes situações. São como encruzilhadas no seu programa, onde diferentes
caminhos são escolhidos dependendo das condições encontradas.
local pontos = 850
if pontos >= 1000 then
print("Você alcançou o nível Mestre!")
elseif pontos >= 500 then
print("Você é um jogador Avançado!")
elseif pontos >= 100 then
print("Continue assim, Iniciante!")
else
print("Bem-vindo ao jogo!")
end
Use if para a primeira condição, elseif para condições alternativas, e else como uma
opção padrão quando nenhuma condição anterior for verdadeira. Essa estrutura é
extremamente versátil e você a usará constantemente na programação de jogos.
Loops: for, while e repeat
Loops são estruturas que repetem blocos de código automaticamente, economizando tempo e tornando seu código mais eficiente. Imagine ter que
escrever a mesma linha 100 vezes - loops fazem isso por você!
for i = 1, 10 do
print(i)
end
1
Loop For
Repete um número específico de vezes
local vida = 100
while vida > 0 do
vida = vida - 10
end
2
Loop While
Repete enquanto uma condição for verdadeira
local contador = 0
repeat
contador += 1
until contador == 5
3
Loop Repeat
Executa pelo menos uma vez, depois verifica a
condição
FĀµfÜpì p³ LĀa: cäafã¾ p ca³ajaì
Funções são blocos de código reutilizáveis que executam tarefas específicas. Pense nelas como máquinas especializadas: você fornece uma entrada,
ela processa e retorna um resultado. Funções tornam seu código organizado, limpo e fácil de manter.
-- Definindo uma função simples
local function saudar(nome)
return "Olá, " .. nome .. "!"
end
-- Chamando a função
print(saudar("Maria")) -- Olá, Maria!
-- Função com múltiplos parâmetros
local function calcularDano(ataque, defesa)
local dano = ataque - defesa
if dano < 0 then
dano = 0
end
return dano
end
local danoFinal = calcularDano(50, 20)
print(danoFinal) -- 30
Vaµøapµì jaì FĀµfÜpì
Reutilização de código
Organização melhorada
Facilita debugging
Código mais legível
Manutenção simplificada
Usar funções adequadamente é marca de um programador
experiente e profissional.
Täaba«aµj¾ c¾³ ìøäµì p
³aµáĀ«afã¾ jp øpĝø¾
Strings são sequências de caracteres que representam texto. No Roblox, você usará
strings constantemente: nomes de jogadores, mensagens de chat, diálogos de NPCs,
placares e muito mais. Lua oferece ferramentas poderosas para manipular texto.
local mensagem = "Bem-vindo ao Roblox!"
-- Concatenação (juntar strings)
local saudacao = "Olá, " .. "jogador!"
-- Comprimento da string
print(#mensagem) -- 20
-- Funções úteis
print(string.upper(mensagem)) -- BEM-VINDO AO ROBLOX!
print(string.lower(mensagem)) -- bem-vindo ao roblox!
print(string.sub(mensagem, 1, 11)) -- Bem-vindo a
print(string.find(mensagem, "Roblox")) -- 15
-- Substituição
local nova = string.gsub(mensagem, "Roblox", "jogo")
print(nova) -- Bem-vindo ao jogo!
Tab«pì: a pìøäĀøĀäa jp jaj¾ì Āµja³pµøa« j¾ LĀa
Tables são a estrutura de dados mais versátil e importante em Lua. Elas funcionam como arrays, dicionários e objetos simultaneamente, permitindo
armazenar e organizar informações complexas de forma eficiente. Praticamente tudo em Lua pode ser representado usando tables.
local frutas = {"maçã", "banana", "laranja"}
print(frutas[1]) -- maçã
print(#frutas) -- 3
table.insert(frutas, "uva")
table.remove(frutas, 2)
AääaĞ (Lìøa Iµjpĝaja)
local jogador = {
nome = "Pedro",
nivel = 10,
moedas = 500
}
print(jogador.nome) -- Pedro
print(jogador["nivel"]) -- 10
jogador.moedas = 600
Dc¾µáä¾ (Caėp-Va«¾ä)
Tables podem conter qualquer tipo de dado, incluindo outras tables, permitindo criar estruturas de dados complexas como inventários, sistemas de
progressão e bancos de dados de jogadores.
Explorando o Roblox Studio
O Roblox Studio é o ambiente de desenvolvimento integrado (IDE) onde toda a mágica
acontece. É uma ferramenta profissional e gratuita que combina editor 3D, editor de
código, teste de jogos e publicação - tudo em um só lugar.
Iµøpäacp IµøĀøėa
Painéis organizados com Explorer, Properties, Toolbox e viewport 3D para navegação
eficiente
Tpìøp Iµìøaµøâµp¾
Teste seu jogo imediatamente com um clique, simulando múltiplos jogadores
Ejø¾ä jp Scäáø R¾bĀìø¾
Autocompletar, destaque de sintaxe e debugging integrado para produtividade máxima
HpäaäãĀa jp ¾b¥pø¾ì µ¾
Ę¾ä¨ìáacp
O workspace é o container principal onde todos os objetos visíveis do seu jogo existem.
Compreender a hierarquia de objetos é fundamental, pois determina como elementos se
relacionam, herdam propriedades e interagem entre si.
01
W¾ä¨ìáacp
Contêiner raiz para todo o conteúdo 3D do jogo
02
Paäøì p M¾jp«ì
Objetos físicos que compõem o ambiente do jogo
03
Scäáøì p T¾¾«ì
Código que adiciona comportamento e interatividade
04
Caäacøpäì
Modelos de jogadores com humanoides e acessórios
Objetos filhos herdam transformações dos pais. Quando você move um modelo, todas
as partes dentro dele se movem junto. Essa hierarquia torna a organização e
manipulação de objetos complexos muito mais gerenciável.

Instances são a base de tudo no Roblox. Cada objeto no seu jogo - desde uma simples parte até um script complexo - é uma instância de uma classe
específica. Compreender instances é essencial para manipular objetos programaticamente.
-- Criando uma nova instance
local novaPart = Instance.new("Part")
novaPart.Parent = workspace
novaPart.Size = Vector3.new(10, 1, 10)
novaPart.Position = Vector3.new(0, 5, 0)
novaPart.BrickColor = BrickColor.new("Bright red")
novaPart.Material = Enum.Material.Neon
Pense em instances como objetos do mundo real que pertencem a categorias.
Uma cadeira é uma instância da categoria "móvel". No Roblox, uma Part é uma
instância da classe "Part", com propriedades específicas como tamanho, cor e
posição.
Pä¾áäpjajpì pììpµcaì j¾ì ¾b¥pø¾ì
Cada objeto no Roblox possui propriedades que definem suas características e comportamento. Modificar propriedades permite customizar
completamente a aparência e funcionalidade de qualquer elemento do seu jogo.
SĨp
Dimensões do objeto (largura, altura, profundidade)
P¾ìø¾µ
Coordenadas no espaço 3D (X, Y, Z)
C¾«¾ä/Maøpäa«
Aparência visual e textura da superfície
Aµc¾äpj
Define se o objeto é afetado pela física
TäaµìáaäpµcĞ
Nível de opacidade (0 = sólido, 1 = invisível)
CaµC¾««jp
Determina se objetos colidem com este
Acessar e modificar propriedades via script oferece controle dinâmico total sobre seu jogo, permitindo criar experiências interativas e responsivas.
Métodos mais utilizados na programação
Métodos são funções especiais que pertencem a objetos específicos, permitindo realizar ações como criar, destruir, clonar ou modificar instances.
Dominar métodos essenciais acelera drasticamente seu desenvolvimento.
-- Instance.new() - Criar novos objetos
local parte = Instance.new("Part")
-- :Clone() - Duplicar objetos existentes
local copia = workspace.PartOriginal:Clone()
copia.Parent = workspace
-- :Destroy() - Remover objetos permanentemente
workspace.PartVelha:Destroy()
-- :FindFirstChild() - Buscar objetos filhos
local script = workspace:FindFirstChild("MeuScript")
-- :WaitForChild() - Esperar um objeto carregar
local parte = workspace:WaitForChild("Plataforma")
-- :GetChildren() - Obter todos os filhos
local filhos = workspace:GetChildren()
for _, filho in pairs(filhos) do
print(filho.Name)
end
Sìøp³a jp pėpµø¾ì: C¾µµpcø¾µì p Sµa«ì
Eventos são o coração da interatividade no Roblox. Eles permitem que seu código reaja a ações específicas: quando um jogador clica em um botão,
quando um objeto toca outro, ou quando o tempo passa. Entender eventos transforma seu jogo de estático para dinâmico.
local parte = workspace.Botao
-- Detectar quando tocada
parte.Touched:Connect(function(hit)
print("Algo tocou o botão!")
-- Verificar se foi um jogador
local personagem = hit.Parent
local humanoid = personagem:FindFirstChild("Humanoid")
if humanoid then
print("Um jogador tocou!")
end
end)
C¾µpcøaµj¾ a Eėpµø¾ì
-- Salvar a conexão
local conexao = parte.Touched:Connect(function()
print("Evento disparado!")
end)
-- Desconectar quando não precisar mais
wait(5)
conexao:Disconnect()
print("Evento desconectado")
Dpìc¾µpcøaµj¾ Eėpµø¾ì
Desconectar eventos quando não são mais necessários previne
vazamentos de memória e melhora a performance.
Rp³¾øpEėpµøì p Rp³¾øpFĀµcø¾µì
RemoteEvents e RemoteFunctions são ferramentas cruciais para comunicação entre servidor e cliente no Roblox. Eles permitem que scripts de diferentes
contextos conversem, mantendo a segurança e integridade do jogo.
-- Cliente para Servidor
remoteEvent:FireServer(dados)
-- Servidor para Cliente
remoteEvent:FireClient(jogador, dados)
remoteEvent:FireAllClients(dados)
Rp³¾øpEėpµø
Usado para comunicação unidirecional. O servidor pode disparar
eventos para clientes, e clientes podem enviar informações ao
servidor. Ideal para ações que não requerem resposta imediata.
-- Cliente invoca servidor
local resposta = remoteFunction:InvokeServer(pergunta)
-- Servidor responde
remoteFunction.OnServerInvoke = function(jogador, dados)
return calcularResultado(dados)
end
Rp³¾øpFĀµcø¾µ
Usado quando você precisa de uma resposta. Funciona como uma
pergunta e resposta: o cliente pergunta ao servidor algo, e espera uma
resposta antes de continuar.
C¾³Āµcafã¾ pµøäp c«pµøp p
ìpäėj¾ä
A arquitetura cliente-servidor do Roblox garante que seu jogo funcione de forma segura e
sincronizada para todos os jogadores. O servidor mantém a verdade absoluta do estado
do jogo, enquanto clientes exibem e enviam inputs.
1C«pµøp pµėa afã¾
Jogador pressiona botão de pular
2Späėj¾ä ėa«ja
Verifica se a ação é permitida
3Späėj¾ä aøĀa«Ĩa
Aplica a física do pulo
4Späėj¾ä äpá«ca
Envia atualização para todos os clientes
Nunca confie completamente no cliente! Sempre valide ações críticas no servidor para
prevenir trapaças e exploits. Um hacker pode modificar seu LocalScript, mas jamais pode
modificar ServerScripts.
Täaba«aµj¾ c¾³ Paäøì p M¾jp«ì
Parts são os blocos de construção básicos do Roblox - objetos 3D simples que você pode moldar, colorir e programar. Models são coleções de parts
agrupadas, permitindo criar objetos complexos como veículos, edifícios ou personagens.
local parte = Instance.new("Part")
parte.Parent = workspace
parte.Size = Vector3.new(10, 2, 10)
parte.Anchored = true
parte.Material = Enum.Material.Grass
parte.BrickColor = BrickColor.new("Forest green")
Cäaµj¾ Paäøì
local modelo = Instance.new("Model")
modelo.Parent = workspace
modelo.Name = "MinhaEstrutura"
-- Adicionar parts ao model
parte.Parent = modelo
-- Definir ponto de pivô
modelo.PrimaryPart = parte
-- Mover o modelo inteiro
modelo:MoveTo(Vector3.new(0, 50, 0))
Täaba«aµj¾ c¾³ M¾jp«ì
Manipulando a posição e rotação de objetos
Controlar onde objetos aparecem e como estão orientados é fundamental para criar experiências 3D convincentes. O Roblox usa um sistema de
coordenadas cartesianas 3D onde X representa direita/esquerda, Y representa cima/baixo, e Z representa frente/trás.
local parte = workspace.MinhaPartelocal parte = workspace.MinhaParte
-- Modificar posição diretamente
parte.Position = Vector3.new(10, 5, -15)
-- Mover relativamente
parte.Position = parte.Position + Vector3.new(0, 5, 0)
-- Rotação usando Orientation (graus)
parte.Orientation = Vector3.new(0, 45, 0) -- Rotacionar 45° no eixo Y
-- Rotação usando CFrame (mais preciso)
parte.CFrame = parte.CFrame * CFrame.Angles(0, math.rad(45), 0)
Position
Define onde o centro do objeto está no
espaço 3D
Orientation
Ângulos em graus para rotações simples
CFrame
Sistema avançado combinando posição e
rotação
CFäa³p ėì Vpcø¾ä3: ãĀaµj¾ Āìaä caja Ā³
Compreender a diferença entre CFrame e Vector3 é essencial para manipulação eficiente de objetos no Roblox. Embora ambos lidem com posição, têm
propósitos e capacidades diferentes.
local posicao = Vector3.new(10, 5, 0)
local direcao = Vector3.new(0, 1, 0)
local tamanho = Vector3.new(4, 8, 4)
Vpcø¾ä3
Representa apenas um ponto no espaço 3D com coordenadas X, Y, Z.
Perfeito para posições simples, direções, velocidades e tamanhos.
Simples e direto
Apenas posição
Operações matemáticas básicas
local cf = CFrame.new(10, 5, 0)
local cf2 = cf * CFrame.Angles(0, math.rad(90), 0)
-- Movimento relativo ao objeto
parte.CFrame = parte.CFrame * CFrame.new(0, 0, -5)
CFäa³p
Representa posição E orientação simultâneas. Essencial para
movimentos complexos, rotações, e quando precisar manter a
orientação exata de um objeto.
Posição + rotação
Movimentos relativos
Interpolação suave
Regra geral: use Vector3 para posições simples e direções; use CFrame quando rotação importar ou para movimentos relativos ao objeto.
Cäaµj¾ aµ³afÜpì báìcaì c¾³ TĘppµSpäėcp
TweenService é a ferramenta profissional do Roblox para criar animações suaves e profissionais de propriedades de objetos. Em vez de mudanças
instantâneas, tweens criam transições graduais que parecem naturais e polidas.
local TweenService = game:GetService("TweenService")
local parte = workspace.Porta
-- Configurar propriedades da animação
local informacaoTween = TweenInfo.new(
2, -- Duração em segundos
Enum.EasingStyle.Quad, -- Estilo de movimento
Enum.EasingDirection.Out, -- Direção da suavização
0, -- Repetições (0 = sem repetir)
false, -- Reverter ao final?
0 -- Delay antes de iniciar
)
-- Definir propriedades finais
local objetivoPropriedades = {
Position = parte.Position + Vector3.new(0, 10, 0),
Transparency = 0.5
}
-- Criar e executar a animação
local tween = TweenService:Create(parte, informacaoTween, objetivoPropriedades)
tween:Play()
TweenService pode animar qualquer propriedade numérica: tamanho, posição, cor, transparência, e muito mais. É perfeito para portas que abrem,
plataformas que se movem, e efeitos visuais impressionantes.
Sìøp³a jp ìca j¾ R¾b«¾ĝ
O motor de física do Roblox simula gravidade, colisões, forças e momentum automaticamente, criando interações realistas entre objetos. Compreender
física é fundamental para criar jogos que parecem naturais e responsivos.
01
Gäaėjajp
Puxa objetos não ancorados para baixo a 196.2 studs/segundo²
02
C¾«ìÜpì
Objetos sólidos não atravessam uns aos outros
03
Fäcfã¾
Superfícies resistem ao movimento de objetos sobre elas
04
E«aìøcjajp
Objetos podem quicar ao colidir
local parte = workspace.Bola
parte.Anchored = false
parte.CustomPhysicalProperties =
PhysicalProperties.new(
0.7, -- Densidade
0.3, -- Fricção
0.9 -- Elasticidade
)
Objetos ancorados ignoram completamente a física. Use Anchored = true para construções estáticas como chão, paredes e decorações.
B¾jĞVp«¾cøĞ, B¾jĞP¾ìø¾µ p ¾Āøä¾ì ³¾jcaj¾äpì
Body movers são objetos especiais que aplicam forças físicas em parts, permitindo criar movimentos complexos que respeitam a física do jogo. Eles são
essenciais para criar veículos, plataformas móveis e objetos com movimento controlado.
B¾jĞVp«¾cøĞ
Aplica velocidade constante em uma direção específica, ignorando fricção e outras forças. Perfeito para projéteis e objetos que devem
manter velocidade.
B¾jĞP¾ìø¾µ
Move suavemente um objeto para uma posição alvo, como se puxado por uma mola invisível. Ideal para plataformas flutuantes.
B¾jĞGĞä¾
Mantém ou força uma rotação específica, resistindo a torques externos. Essencial para estabilizar veículos voadores.
Dpøpcfã¾ jp c¾«ìã¾ c¾³ T¾Ācpj pėpµøì
O evento Touched é uma das ferramentas mais utilizadas no Roblox, disparando sempre que um objeto físico toca em outro. É fundamental para criar
portas que abrem, armadilhas que machucam, e coletáveis que desaparecem.
local parte = workspace.PortaAutomatica
local debounce = false -- Prevenir múltiplos disparos rápidos
parte.Touched:Connect(function(hit)
-- Evitar spam de eventos
if debounce then return end
debounce = true
-- Verificar se foi um personagem de jogador
local personagem = hit.Parent
local humanoid = personagem:FindFirstChild("Humanoid")
if humanoid then
local jogador = game.Players:GetPlayerFromCharacter(personagem)
print(jogador.Name .. " tocou na porta!")
-- Abrir porta
parte.Transparency = 0.5
parte.CanCollide = false
wait(3)
-- Fechar porta
parte.Transparency = 0
parte.CanCollide = true
end
wait(0.5)
debounce = false
end)
Sempre use debouncing para prevenir que o evento dispare dezenas de vezes por segundo, o que causaria lag e bugs.

Raycasting projeta um raio invisível através do espaço 3D e detecta o primeiro objeto que ele atinge. É a técnica por trás de armas de fogo, visão de
NPCs, e detecção de chão em sistemas de movimento avançados.

Imagine uma linha laser invisível que você dispara de um ponto em uma
direção. O raycast retorna informações sobre o primeiro objeto atingido,
incluindo posição exata do impacto, o objeto atingido, e a distância
percorrida.
local origem = workspace.Arma.Position
local direcao = workspace.Arma.CFrame.LookVector * 100
local raycastParams = RaycastParams.new()
raycastParams.FilterType = Enum.RaycastFilterType.Exclude
raycastParams.FilterDescendantsInstances = {workspace.Arma}
local resultado = workspace:Raycast(origem, direcao,
raycastParams)
if resultado then
print("Atingiu: " .. resultado.Instance.Name)
print("Posição: " .. tostring(resultado.Position))
print("Distância: " .. resultado.Distance)
end

Iµøpäacp j¾ ĀìĀáä¾ c¾³ ScäppµGĀì
ScreenGuis são containers para todos os elementos de interface do usuário (UI) no Roblox. Eles aparecem na tela do jogador e podem conter botões,
textos, imagens e outros elementos interativos essenciais para a experiência do usuário.
-- Criar uma ScreenGui no jogador
local jogador = game.Players.LocalPlayer
local screenGui = Instance.new("ScreenGui")
screenGui.Parent = jogador:WaitForChild("PlayerGui")
screenGui.ResetOnSpawn = false -- Não destruir ao morrer
-- Adicionar um frame
local frame = Instance.new("Frame")
frame.Size = UDim2.new(0.3, 0, 0.4, 0) -- 30% largura, 40% altura
frame.Position = UDim2.new(0.35, 0, 0.3, 0) -- Centralizar
frame.BackgroundColor3 = Color3.fromRGB(50, 50, 50)
frame.BorderSizePixel = 0
frame.Parent = screenGui
-- Adicionar cantos arredondados
local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 12)
corner.Parent = frame
Use UDim2 para posições e tamanhos responsivos que se adaptam a diferentes resoluções de tela. O primeiro número é escala (0-1), o segundo é offset
em pixels.
Cäaµj¾ b¾øÜpì p p«p³pµø¾ì µøpäaøė¾ì
Botões transformam interfaces passivas em experiências interativas. No Roblox, TextButtons e ImageButtons permitem que jogadores cliquem e
interajam com sua UI, disparando eventos quando pressionados.
Fppjbac¨ VìĀa«
Botões profissionais mudam de aparência quando o jogador
passa o mouse ou clica, fornecendo feedback claro de
interatividade.
local botao = Instance.new("TextButton")
botao.Size = UDim2.new(0, 200, 0, 50)
botao.Position = UDim2.new(0.5, -100, 0.5, -25)
botao.Text = "Começar Jogo"
botao.Font = Enum.Font.GothamBold
botao.TextSize = 20
botao.TextColor3 = Color3.new(1, 1, 1)
botao.BackgroundColor3 = Color3.fromRGB(0, 170, 255)
botao.Parent = screenGui
-- Evento de clique
botao.MouseButton1Click:Connect(function()
print("Botão clicado!")
botao.Text = "Carregando..."
end)
-- Hover effect
botao.MouseEnter:Connect(function()
botao.BackgroundColor3 = Color3.fromRGB(0, 200, 255)
end)
botao.MouseLeave:Connect(function()
botao.BackgroundColor3 = Color3.fromRGB(0, 170, 255)
end)
TextLabels, TextBoxes e ImageLabels
Estes três elementos formam o núcleo da apresentação de informações visuais e coleta de input do usuário. Cada um serve um propósito específico na
construção de interfaces completas e funcionais.
local label = Instance.new("TextLabel")
label.Text = "Pontos: 0"
label.Font = Enum.Font.Gotham
label.TextSize = 18
label.TextColor3 = Color3.new(1, 1, 1)
label.BackgroundTransparency = 1
TextLabel
Exibe texto estático que o jogador pode ler
mas não modificar. Perfeito para títulos,
descrições, estatísticas e instruções.
local textBox =
Instance.new("TextBox")
textBox.PlaceholderText = "Digite seu
nome..."
textBox.Text = ""
textBox.TextEditable = true
textBox.ClearTextOnFocus = false
textBox.FocusLost:Connect(function(e
nterPressed)
if enterPressed then
print("Nome digitado: " ..
textBox.Text)
end
end)
TextBox
Campo de entrada onde jogadores podem
digitar texto. Essencial para sistemas de
chat, busca, nomeação de itens e
formulários.
local imageLabel =
Instance.new("ImageLabel")
imageLabel.Image =
"rbxassetid://1234567890"
imageLabel.ScaleType =
Enum.ScaleType.Fit
imageLabel.BackgroundTransparency
= 1
imageLabel.Size = UDim2.new(0, 64, 0,
64)
ImageLabel
Exibe imagens, ícones e texturas.
Fundamental para logos, avatares, ícones de
itens e elementos visuais decorativos.
LaоĀø aĀø¾³áøc¾ c¾³ UILìøLaоĀø p UIGäjLaоĀø
Layouts automáticos economizam incontáveis horas organizando elementos UI automaticamente. Em vez de posicionar manualmente cada item, esses
componentes fazem o trabalho pesado, criando listas e grades perfeitas instantaneamente.
local frame = Instance.new("Frame")
frame.Size = UDim2.new(0, 300, 0, 400)
frame.Parent = screenGui
local listLayout = Instance.new("UIListLayout")
listLayout.Parent = frame
listLayout.SortOrder = Enum.SortOrder.LayoutOrder
listLayout.Padding = UDim.new(0, 10)
listLayout.FillDirection = Enum.FillDirection.Vertical
listLayout.HorizontalAlignment =
Enum.HorizontalAlignment.Center
-- Elementos adicionados automaticamente se organizam!
for i = 1, 5 do
local item = Instance.new("TextButton")
item.Size = UDim2.new(1, -20, 0, 50)
item.Text = "Item " .. i
item.Parent = frame
end
UILìøLaоĀø
Organiza elementos em uma lista vertical ou horizontal com
espaçamento automático. Perfeito para inventários, menus e listas de
itens.
local gridLayout = Instance.new("UIGridLayout")
gridLayout.Parent = frame
gridLayout.CellSize = UDim2.new(0, 80, 0, 80)
gridLayout.CellPadding = UDim2.new(0, 10, 0, 10)
gridLayout.SortOrder = Enum.SortOrder.LayoutOrder
-- Cria uma grade 3x3 automaticamente
for i = 1, 9 do
local cell = Instance.new("ImageButton")
cell.Parent = frame
end
UIGäjLaоĀø
Organiza elementos em uma grade de linhas e colunas. Ideal para lojas de
itens, seleção de personagens e galerias.
Sìøp³a jp µėpµøáä¾ báìc¾
Inventários permitem que jogadores coletem, armazenem e usem itens. Criar um sistema de inventário funcional combina programação de backend
(armazenamento de dados) com frontend (interface visual), demonstrando múltiplas habilidades fundamentais.
-- Estrutura de dados do inventário
local Inventario = {
itens = {},
maxSlots = 20
}
function Inventario:AdicionarItem(nomeItem, quantidade)
-- Verificar se item já existe
for _, item in pairs(self.itens) do
if item.nome == nomeItem then
item.quantidade = item.quantidade + quantidade
return true
end
end
-- Adicionar novo item se houver espaço
if #self.itens < self.maxSlots then
table.insert(self.itens, {
nome = nomeItem,
quantidade = quantidade
})
return true
end
return false -- Inventário cheio
end
function Inventario:RemoverItem(nomeItem, quantidade)
for i, item in pairs(self.itens) do
if item.nome == nomeItem then
item.quantidade = item.quantidade - quantidade
if item.quantidade <= 0 then
table.remove(self.itens, i)
end
return true
end
end
return false
end
function Inventario:TemItem(nomeItem)
for _, item in pairs(self.itens) do
if item.nome == nomeItem then
return true, item.quantidade
end
end
return false, 0
end
DaøaSø¾äpSpäėcp: ìa«ėaµj¾ jaj¾ì j¾ ¥¾aj¾ä
DataStoreService permite salvar dados permanentemente na nuvem do Roblox, garantindo que progresso, itens e estatísticas dos jogadores persistam
entre sessões. É essencial para qualquer jogo que valorize progressão e retenção de jogadores.
local DataStoreService = game:GetService("DataStoreService")
local jogadorData = DataStoreService:GetDataStore("DadosJogador")
game.Players.PlayerAdded:Connect(function(jogador)
local sucesso, dados = pcall(function()
return jogadorData:GetAsync(jogador.UserId)
end)
if sucesso and dados then
-- Carregar dados salvos
jogador.leaderstats.Moedas.Value = dados.Moedas or 0
jogador.leaderstats.Nivel.Value = dados.Nivel or 1
else
-- Dados padrão para novo jogador
jogador.leaderstats.Moedas.Value = 0
jogador.leaderstats.Nivel.Value = 1
end
end)
game.Players.PlayerRemoving:Connect(function(jogador)
local dados = {
Moedas = jogador.leaderstats.Moedas.Value,
Nivel = jogador.leaderstats.Nivel.Value
}
pcall(function()
jogadorData:SetAsync(jogador.UserId, dados)
end)
end)
B¾aì Päáøcaì
Sempre use pcall para capturar erros
Salve dados quando jogador sair
Implemente sistema de autosave
Use UserId como chave única
Não salve dados com muita frequência (limites de API)
DataStores têm limites de requisições por minuto. Salvar a cada
mudança causará erros. Implemente debouncing ou autosave em
intervalos.
Täaba«aµj¾ c¾³ «pajpäìøaøì
Leaderstats são estatísticas de jogadores exibidas automaticamente no placar do jogo. São a forma mais rápida e visual de mostrar informações
importantes como pontos, moedas, nível ou mortes. Todo jogo competitivo ou com progressão deve implementar leaderstats.
game.Players.PlayerAdded:Connect(function(jogador)
-- Criar pasta de leaderstats
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats"
leaderstats.Parent = jogador
-- Criar estatística de Moedas
local moedas = Instance.new("IntValue")
moedas.Name = "Moedas"
moedas.Value = 0
moedas.Parent = leaderstats
-- Criar estatística de Nível
local nivel = Instance.new("IntValue")
nivel.Name = "Nível"
nivel.Value = 1
nivel.Parent = leaderstats
-- Criar estatística de Kills
local kills = Instance.new("IntValue")
kills.Name = "Eliminações"
kills.Value = 0
kills.Parent = leaderstats
end)
-- Modificar valores
local jogador = game.Players:FindFirstChild("NomeJogador")
if jogador then
jogador.leaderstats.Moedas.Value = jogador.leaderstats.Moedas.Value + 10
end
O nome da pasta DEVE ser exatamente "leaderstats" (minúsculo) para aparecer no placar. Os valores dentro aparecerão automaticamente ordenados
alfabeticamente.
PlayerGui vs StarterGui
Compreender a diferença entre PlayerGui e StarterGui é crucial para gerenciar interfaces de usuário corretamente. Ambos contêm GUIs, mas funcionam
de maneiras fundamentalmente diferentes no ciclo de vida do jogo.
-- Modificar template (afeta novos jogadores)
local gui = Instance.new("ScreenGui")
gui.Parent = game.StarterGui
StarterGui
Container de templates que o Roblox automaticamente copia para cada
jogador quando entram no jogo. Modificações aqui afetam apenas
novos jogadores ou após respawn. Use StarterGui para definir a
interface padrão inicial do jogo.
Template/modelo de GUIs
Modificações não afetam jogadores atuais
Bom para configuração inicial
-- Modificar GUI de jogador específico
local jogador = game.Players.LocalPlayer
local gui = Instance.new("ScreenGui")
gui.Parent = jogador:WaitForChild("PlayerGui")
PlayerGui
Container individual de cada jogador contendo suas GUIs ativas.
Modificações aqui afetam imediatamente aquele jogador específico.
Use PlayerGui quando precisar atualizar a interface durante o jogo.
GUIs ativas do jogador
Mudanças imediatas e visíveis
Único para cada jogador
Sáaʵµ jp ¥¾aj¾äpì p SáaʵL¾caø¾µì
SpawnLocations determinam onde jogadores aparecem quando entram no jogo ou respawnam após morrer. Controlar spawns é fundamental para
experiências multiplayer, sistemas de equipes e design de níveis.
C¾µĀäaµj¾ Sáaʵì
SpawnLocations são parts especiais com propriedades únicas. O Roblox
escolhe automaticamente um spawn aleatório disponível, mas você pode
controlar esse comportamento programaticamente.
-- Criar SpawnLocation
local spawn = Instance.new("SpawnLocation")
spawn.Size = Vector3.new(6, 1, 6)
spawn.Position = Vector3.new(0, 2, 0)
spawn.Anchored = true
spawn.CanCollide = true
spawn.Transparency = 0.5
spawn.Duration = 0 -- Desabilitar cooldown
spawn.Neutral = true -- Qualquer equipe pode usar
spawn.Parent = workspace
-- Teleportar jogador para posição específica
local function respawnJogador(jogador)
local personagem = jogador.Character
if personagem then
local humanoidRootPart =
personagem:FindFirstChild("HumanoidRootPart")
if humanoidRootPart then
humanoidRootPart.CFrame = CFrame.new(0, 10, 0)
end
end
end
Use a propriedade Neutral para spawns acessíveis por todas as equipes, ou defina TeamColor para spawns exclusivos de equipe.
Teams e sistemas de equipes
O serviço Teams permite criar jogos competitivos com múltiplas facções, implementando automaticamente funcionalidades como spawn por equipe,
friendly fire control e placar separado. Equipes são essenciais para jogos PvP, batalhas e competições.
local Teams = game:GetService("Teams")
-- Criar equipe Vermelha
local equipeVermelha = Instance.new("Team")
equipeVermelha.Name = "Vermelhos"
equipeVermelha.TeamColor = BrickColor.new("Bright red")
equipeVermelha.AutoAssignable = true
equipeVermelha.Parent = Teams
-- Criar equipe Azul
local equipeAzul = Instance.new("Team")
equipeAzul.Name = "Azuis"
equipeAzul.TeamColor = BrickColor.new("Bright blue")
equipeAzul.AutoAssignable = true
equipeAzul.Parent = Teams
-- Atribuir jogador a uma equipe
game.Players.PlayerAdded:Connect(function(jogador)
wait(1)
local equipes = Teams:GetTeams()
-- Balancear equipes
local menorEquipe = equipes[1]
for _, equipe in pairs(equipes) do
if #equipe:GetPlayers() < #menorEquipe:GetPlayers() then
menorEquipe = equipe
end
end
jogador.Team = menorEquipe
print(jogador.Name .. " entrou na equipe " .. menorEquipe.Name)
end)


Crie batalhas épicas com múltiplas facções competindo


Sistema de equipes se integra automaticamente com spawns e placar
S¾µì p ppø¾ì ³Āìcaì c¾³ S¾Āµj ¾b¥pcøì
Áudio transforma jogos silenciosos em experiências imersivas. Sons adicionam feedback tátil a ações, música estabelece atmosfera emocional, e
efeitos sonoros direcionais ajudam jogadores a localizar eventos importantes no espaço 3D.
Tá¾ì jp S¾µì
SFX: Efeitos sonoros curtos para ações
Música: Trilhas de fundo longas e looped
Ambiente: Sons naturais do ambiente
Vozes: Diálogos e narrações
local som = Instance.new("Sound")
som.SoundId = "rbxassetid://1234567890"
som.Volume = 0.5 -- 0 a 1
som.Pitch = 1 -- Velocidade de reprodução
som.Looped = false
som.Parent = workspace
-- Reproduzir som
som:Play()
-- Som 3D posicional
som.Parent = workspace.Parte
som.RollOffMaxDistance = 100
som.RollOffMinDistance = 10
-- Parar som
som:Stop()
-- Ajustar volume gradualmente
local TweenService = game:GetService("TweenService")
local tween = TweenService:Create(
som,
TweenInfo.new(2),
{Volume = 0}
)
tween:Play()
Use a Biblioteca de Áudio do Roblox ou faça upload de seus próprios sons. Sons anexados a parts são 3D (volume varia com distância), enquanto sons
em Workspace ou SoundService são globais.
Lighting e efeitos visuais
O serviço Lighting controla toda iluminação, atmosfera e tempo no seu jogo. Ajustar propriedades de lighting pode transformar completamente o clima e
emoção da experiência - de dias ensolarados brilhantes a noites misteriosas e sombrias.
local Lighting = game:GetService("Lighting")
-- Configurações básicas de luz
Lighting.Ambient = Color3.fromRGB(100, 100, 120) -- Luz ambiente
Lighting.Brightness = 2 -- Intensidade geral
Lighting.OutdoorAmbient = Color3.fromRGB(127, 127, 127)
Lighting.ColorShift_Top = Color3.fromRGB(255, 200, 150)
-- Tempo do dia (0-24 horas)
Lighting.ClockTime = 18 -- 6 PM (pôr do sol)
Lighting.TimeOfDay = "14:30:00" -- 2:30 PM
-- Efeitos atmosféricos
local bloom = Instance.new("BloomEffect")
bloom.Intensity = 0.5
bloom.Size = 24
bloom.Threshold = 2
bloom.Parent = Lighting
local sunRays = Instance.new("SunRaysEffect")
sunRays.Intensity = 0.1
sunRays.Spread = 0.5
sunRays.Parent = Lighting
local colorCorrection = Instance.new("ColorCorrectionEffect")
colorCorrection.Brightness = 0.05
colorCorrection.Contrast = 0.1
colorCorrection.Saturation = 0.2
colorCorrection.TintColor = Color3.fromRGB(255, 255, 255)
colorCorrection.Parent = Lighting
Cc«¾ Da/N¾øp
Crie dinâmica temporal mudando
ClockTime continuamente
Aø³¾ìpäa
Combine múltiplos efeitos para criar
climas únicos
Ppä¾ä³aµcp
Efeitos de lighting podem impactar FPS
em dispositivos fracos
Paäøc«pE³øøpäì áaäa ppø¾ì pìápcaì
ParticleEmitters criam efeitos visuais impressionantes como fogo, fumaça, faíscas, magia e explosões. São ferramentas poderosas para adicionar vida,
movimento e impacto visual aos seus jogos, tornando ações mais satisfatórias e espetaculares.
local parte = workspace.Tocha
local emitter = Instance.new("ParticleEmitter")
-- Configurações visuais
emitter.Texture = "rbxasset://textures/particles/smoke_main.dds"
emitter.Color = ColorSequence.new(
Color3.fromRGB(255, 100, 0),
Color3.fromRGB(255, 0, 0)
)
emitter.Size = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0.5),
NumberSequenceKeypoint.new(1, 2)
})
emitter.Transparency = NumberSequence.new({
NumberSequenceKeypoint.new(0, 0),
NumberSequenceKeypoint.new(1, 1)
})
-- Comportamento
emitter.Lifetime = NumberRange.new(1, 2)
emitter.Rate = 50 -- Partículas por segundo
emitter.Speed = NumberRange.new(2, 5)
emitter.SpreadAngle = Vector2.new(30, 30)
emitter.Rotation = NumberRange.new(0, 360)
emitter.RotSpeed = NumberRange.new(-50, 50)
emitter.Parent = parte
Caì¾ì jp Uì¾ C¾³Āµì
Fogo e explosões
Fumaça e névoa
Efeitos mágicos e habilidades
Pegadas e rastros
Chuva e neve
Faíscas e eletricidade
Combine múltiplos emitters para efeitos complexos e realistas. Use
ColorSequence e NumberSequence para animações ao longo da vida da
partícula.
Cäaµj¾ NPCì c¾³ HĀ³aµ¾jì
NPCs (Non-Player Characters) são personagens controlados por IA que povoam seu mundo. Humanoids são o componente central que permite criar
personagens com animações, saúde, morte e comportamento semelhante aos jogadores reais.
-- Criar modelo de NPC
local npc = Instance.new("Model")
npc.Name = "Guarda"
npc.Parent = workspace
-- Criar parte principal (torso)
local torso = Instance.new("Part")
torso.Name = "HumanoidRootPart"
torso.Size = Vector3.new(2, 2, 1)
torso.Position = Vector3.new(0, 3, 0)
torso.Anchored = false
torso.Parent = npc
-- Criar Humanoid
local humanoid = Instance.new("Humanoid")
humanoid.Parent = npc
humanoid.MaxHealth = 100
humanoid.Health = 100
humanoid.WalkSpeed = 16
humanoid.JumpPower = 50
-- Detectar morte do NPC
humanoid.Died:Connect(function()
print(npc.Name .. " morreu!")
wait(5)
npc:Destroy()
end)
-- Aplicar dano ao NPC
humanoid:TakeDamage(20)
-- Curar NPC
humanoid.Health = math.min(humanoid.Health + 30, humanoid.MaxHealth)
Para NPCs completos com aparência de jogador, use modelos da Toolbox ou crie no Avatar Editor. NPCs podem usar todos os sistemas de Humanoid:
animações, ferramentas, roupas e acessórios.
PaøµjµSpäėcp áaäa ³¾ė³pµøafã¾ µøp«pµøp
PathfindingService calcula automaticamente rotas que evitam obstáculos, permitindo que NPCs naveguem inteligentemente pelo seu mundo. É essencial
para criar inimigos perseguidores, companheiros que seguem o jogador, ou qualquer personagem que precisa se mover autonomamente.
local PathfindingService = game:GetService("PathfindingService")
local function moverNPCpara(npc, destino)
local humanoid = npc:FindFirstChild("Humanoid")
local rootPart = npc:FindFirstChild("HumanoidRootPart")
if not humanoid or not rootPart then return end
-- Criar caminho
local path = PathfindingService:CreatePath({
AgentRadius = 2,
AgentHeight = 5,
AgentCanJump = true,
WaypointSpacing = 4,
Costs = {
Water = 20 -- Evitar água
}
})
-- Calcular caminho
local sucesso, erro = pcall(function()
path:ComputeAsync(rootPart.Position, destino)
end)
if sucesso and path.Status == Enum.PathStatus.Success then
local waypoints = path:GetWaypoints()
for _, waypoint in pairs(waypoints) do
if waypoint.Action == Enum.PathWaypointAction.Jump then
humanoid.Jump = true
end
humanoid:MoveTo(waypoint.Position)
humanoid.MoveToFinished:Wait()
end
else
warn("Não foi possível calcular caminho")
end
end
-- Usar a função
local npc = workspace.Inimigo
local jogadorPos = workspace.Jogador.HumanoidRootPart.Position
moverNPCpara(npc, jogadorPos)
FĀµc¾µa«jajpì
Desvio automático de obstáculos
Suporte para pulos
Custos de terreno personalizados
Recalculo dinâmico de rotas
Otimizado para performance
Pathfinding pode ser computacionalmente caro. Use com
moderação e implemente cooldowns para múltiplos
NPCs.
Sìøp³a jp caø ápäì¾µa«Ĩaj¾
Personalizar o sistema de chat permite criar experiências únicas como comandos especiais, filtros customizados, canais de equipe, ou interfaces de chat
completamente redesenhadas. O Roblox oferece APIs robustas para modificar todos os aspectos do chat.
-- ServerScriptService
local ChatService = require(game:GetService("ServerScriptService"):WaitForChild("ChatServiceRunner").ChatService)
-- Esperar chat carregar
ChatService:RegisterProcessCommandsFunction("comando", function(speakerName, message, channelName)
if string.sub(message, 1, 4) == "/vip" then
local speaker = ChatService:GetSpeaker(speakerName)
local player = game.Players:FindFirstChild(speakerName)
if player and player:FindFirstChild("VIPStatus") then
speaker:SendSystemMessage("Bem-vindo VIP!", "System")
return true -- Bloqueia mensagem original
end
end
return false -- Permite mensagem normal
end)
-- Personalizar cor de nome
ChatService.SpeakerAdded:Connect(function(speakerName)
local speaker = ChatService:GetSpeaker(speakerName)
local player = game.Players:FindFirstChild(speakerName)
if player then
-- Mudar cor baseado em rank
if player:GetRankInGroup(123456) >= 250 then
speaker:SetExtraData("ChatColor3", Color3.fromRGB(255, 215, 0))
speaker:SetExtraData("NameColor", Color3.fromRGB(255, 215, 0))
speaker:SetExtraData("Tags", {{Text = "[ADMIN]", Color = Color3.fromRGB(255, 0, 0)}})
end
end
end)
Maä¨pøá«acpSpäėcp p c¾³áäaì µ¾ ¥¾¾
MarketplaceService permite que jogadores comprem Gamepasses, Developer Products e itens premium usando Robux. É a principal forma de monetizar
seus jogos no Roblox, transformando criatividade em receita real.
Ga³páaììpì ėì Dpėp«¾ápä Pä¾jĀcøì
Ga³páaììpì
Compra única permanente. Perfeito para VIP, acesso a áreas
especiais, ou habilidades permanentes.
Dpėp«¾ápä Pä¾jĀcøì
Compras consumíveis e repetíveis. Ideal para moedas, vidas extras
ou power-ups temporários.
local MarketplaceService = game:GetService("MarketplaceService")
local gamepassId = 123456789
local productId = 987654321
-- Verificar se jogador possui gamepass
local function temGamepass(jogador, gamepassId)
local sucesso, possui = pcall(function()
return MarketplaceService:UserOwnsGamePassAsync(jogador.UserId, gamepassId)
end)
return sucesso and possui
end
-- Processar compra de Developer Product
MarketplaceService.ProcessReceipt = function(receiptInfo)
local jogador = game.Players:GetPlayerByUserId(receiptInfo.PlayerId)
if receiptInfo.ProductId == productId then
if jogador then
jogador.leaderstats.Moedas.Value = jogador.leaderstats.Moedas.Value + 1000
return Enum.ProductPurchaseDecision.PurchaseGranted
end
end
return Enum.ProductPurchaseDecision.NotProcessedYet
end
-- Prompt de compra
local botao = script.Parent
botao.MouseButton1Click:Connect(function()
local jogador = game.Players.LocalPlayer
MarketplaceService:PromptGamePassPurchase(jogador, gamepassId)
end)
Tp«pá¾äøSpäėcp áaäa ³ā«øá«¾ì «Āaäpì
TeleportService permite criar universos de jogos interconectados, onde jogadores podem viajar entre diferentes lugares mantendo dados e progresso. É
essencial para MMOs, jogos com lobby + arenas, ou experiências multi-mapa expansivas.
local TeleportService = game:GetService("TeleportService")
-- ID do lugar de destino
local placeIdDestino = 987654321
-- Teleportar um jogador
local function teleportarJogador(jogador, placeId)
local sucesso, erro = pcall(function()
TeleportService:Teleport(placeId, jogador)
end)
if not sucesso then
warn("Falha ao teleportar: " .. erro)
end
end
-- Teleportar grupo de jogadores juntos
local function teleportarGrupo(jogadores, placeId)
local codigo = TeleportService:ReserveServer(placeId)
TeleportService:TeleportToPrivateServer(placeId, codigo, jogadores)
end
-- Teleportar com dados personalizados
local function teleportarComDados(jogador, placeId, dados)
local options = Instance.new("TeleportOptions")
options:SetTeleportData(dados)
TeleportService:TeleportAsync(placeId, {jogador}, options)
end
-- Receber dados após teleporte
local function receberDadosTeleporte(jogador)
local dados = jogador:GetJoinData()
if dados.TeleportData then
print("Dados recebidos:", dados.TeleportData)
end
end
-- Exemplo de uso: Portal
local portal = workspace.Portal
portal.Touched:Connect(function(hit)
local personagem = hit.Parent
local jogador = game.Players:GetPlayerFromCharacter(personagem)
if jogador then
teleportarJogador(jogador, placeIdDestino)
end
end)

Código limpo e bem organizado não é apenas esteticamente agradável - é mais fácil de debugar, manter, expandir e colaborar. Seguir boas práticas desde
o início economiza incontáveis horas de frustração futura e marca a diferença entre programadores amadores e profissionais.
N¾³pµc«aøĀäa C«aäa
Use nomes descritivos e consistentes. jogadorAtual é melhor que
p. Use camelCase para variáveis, PascalCase para classes.
C¾³pµøáä¾ì Úøpì
Explique o "porquê", não o "o quê". Código deve ser auto-
explicativo; comente lógica complexa ou decisões não-óbvias.
OäaµĨafã¾ L¿ca
Agrupe scripts relacionados em pastas. Use ModuleScripts para
código reutilizável. Separe cliente de servidor claramente.
Täaøa³pµø¾ jp Eää¾ì
Sempre use pcall para operações que podem falhar. Previna
crashes com validações de input e nil checks.
Ppä¾ä³aµcp
Evite loops em eventos de alta frequência. Use wait()
apropriadamente. Cache referências usadas múltiplas vezes.
SpĀäaµfa
Nunca confie no cliente para validações críticas. Sempre verifique
permissões no servidor antes de executar ações importantes.
OäaµĨafã¾ jp c¿j¾ p M¾jĀ«pScäáøì
ModuleScripts são a solução profissional para compartilhar código entre múltiplos scripts, criar bibliotecas reutilizáveis e organizar projetos complexos.
Eles funcionam como containers de funções e dados que podem ser importados quando necessário.
-- ModuleScript chamado "UtilMoedas"
local UtilMoedas = {}
function UtilMoedas.adicionar(jogador, quantidade)
if not jogador or not jogador:FindFirstChild("leaderstats") then
return false
end
local moedas = jogador.leaderstats:FindFirstChild("Moedas")
if moedas then
moedas.Value = moedas.Value + quantidade
return true
end
return false
end
function UtilMoedas.remover(jogador, quantidade)
if not jogador or not jogador:FindFirstChild("leaderstats") then
return false
end
local moedas = jogador.leaderstats:FindFirstChild("Moedas")
if moedas and moedas.Value >= quantidade then
moedas.Value = moedas.Value - quantidade
return true
end
return false
end
function UtilMoedas.obter(jogador)
if jogador and jogador:FindFirstChild("leaderstats") then
local moedas = jogador.leaderstats:FindFirstChild("Moedas")
return moedas and moedas.Value or 0
end
return 0
end
return UtilMoedas
Cäaµj¾ Ā³ M¾jĀ«pScäáø
-- Em qualquer outro script
local UtilMoedas = require(game.ReplicatedStorage.UtilMoedas)
local jogador = game.Players.LocalPlayer
-- Usar funções do módulo
UtilMoedas.adicionar(jogador, 100)
UtilMoedas.remover(jogador, 50)
local saldo = UtilMoedas.obter(jogador)
print("Moedas atuais: " .. saldo)
Uìaµj¾ ¾ M¾jĀ«pScäáø
Vaµøapµì
Código reutilizável em múltiplos lugares
Manutenção centralizada
Organização melhorada
Fácil de testar isoladamente
Colaboração simplificada
Debugging: usando print e warn efetivamente
Debugging é a arte de encontrar e corrigir bugs em seu código. As funções print() e warn() são suas ferramentas mais básicas porém essenciais,
permitindo rastrear o fluxo de execução e valores de variáveis em tempo real.
-- Print básico
print("Script iniciado!")
-- Print com múltiplos valores
local jogador = "João"
local pontos = 150
print("Jogador:", jogador, "| Pontos:", pontos)
-- Warn para alertas (aparece em amarelo)
warn("Atenção: Valor inválido detectado!")
-- Print formatado
local mensagem = string.format("Jogador %s tem %d pontos", jogador, pontos)
print(mensagem)
-- Debugging de tables
local inventario = {espada = 1, escudo = 1, pocao = 5}
print("Inventário:")
for item, quantidade in pairs(inventario) do
print(" " .. item .. ": " .. quantidade)
end
-- Rastrear execução de função
local function calcularDano(ataque, defesa)
print("[calcularDano] Entrada: ataque=" .. ataque .. ", defesa=" .. defesa)
local dano = math.max(0, ataque - defesa)
print("[calcularDano] Saída: dano=" .. dano)
return dano
end
-- Checkpoint debugging
print("=== INÍCIO DO PROCESSAMENTO ===")
-- código complexo aqui
print("=== FIM DO PROCESSAMENTO ===")
Use prefixos
Identifique a origem: print("[Sistema de
Combate] ...")
Remove prints em produção
Prints excessivos podem causar lag;
comente ou remova antes de publicar
Monitore a Output
A janela Output no Studio é onde todos os
prints aparecem
Täaøa³pµø¾ jp pää¾ì c¾³ áca««
pcall (protected call) é uma função crítica que protege seu código de crashes. Ela executa uma função em modo protegido, capturando erros ao invés de
deixar todo o script parar. É essencial para operações que podem falhar como DataStores, HTTP requests e operações de rede.
-- Se houver erro, script para completamente
local DataStoreService = game:GetService("DataStoreService")
local minhaData = DataStoreService:GetDataStore("Jogadores")
local dados = minhaData:GetAsync(jogador.UserId)
-- Se GetAsync falhar, nada abaixo executa!
jogador.leaderstats.Moedas.Value = dados.Moedas
print("Dados carregados!")
Sp³ áca«« (ápä¾ì¾)
&
Problema: Um erro na linha do GetAsync impede todo código posterior
de executar.
local DataStoreService = game:GetService("DataStoreService")
local minhaData = DataStoreService:GetDataStore("Jogadores")
local sucesso, resultado = pcall(function()
return minhaData:GetAsync(jogador.UserId)
end)
if sucesso then
-- Dados carregados com sucesso
jogador.leaderstats.Moedas.Value = resultado.Moedas
print("Dados carregados!")
else
-- Erro capturado, usar valores padrão
warn("Falha ao carregar dados:", resultado)
jogador.leaderstats.Moedas.Value = 0
end
print("Script continua normalmente!")
C¾³ áca«« (ìpĀä¾)
'
Solução: Erro é capturado e tratado graciosamente.
Sempre use pcall para DataStores, TeleportService, MarketplaceService, e qualquer operação externa que possa falhar por motivos fora do seu controle.
Oø³Ĩafã¾ jp ápä¾ä³aµcp p³ ìcäáøì
Performance inadequada resulta em lag, FPS baixo e jogadores frustrados. Otimizar scripts não é apenas fazer código rodar mais rápido - é fazer
escolhas inteligentes sobre quando, onde e como executar operações para maximizar eficiência.
-- Ruim: busca repetida
for i = 1, 100 do
game:GetService("Players").LocalPlayer.Character.Humanoid.H
ealth -= 1
end
-- Bom: cache
local humanoid =
game.Players.LocalPlayer.Character.Humanoid
for i = 1, 100 do
humanoid.Health -= 1
end
1
Cacp äppäuµcaì
Acesse serviços e objetos uma vez, armazene em variáveis locais.
Evite workspace:FindFirstChild() em loops.
-- Causa crash
while true do
-- código pesado
end
-- Correto
while true do
-- código pesado
task.wait(0.1) -- Respira entre iterações
end
2
Uìp Ęaø() aáä¾áäaja³pµøp
Loops infinitos sem wait() causam crashes. Adicione delays razoáveis
entre iterações intensivas.
local conexao = parte.Touched:Connect(function()
-- código
end)
-- Quando terminar
conexao:Disconnect()
3
Dpìc¾µpcøp pėpµø¾ì
Eventos não usados continuam consumindo recursos. Desconecte
quando não precisar mais.
-- Ineficiente
for _, jogador in pairs(game.Players:GetPlayers()) do
local char = workspace:FindFirstChild(jogador.Name)
end
-- Eficiente
for _, jogador in pairs(game.Players:GetPlayers()) do
local char = jogador.Character
end
4
Eėøp FµjFäìøC«j p³ «¾¾áì
Buscas repetidas são caras. Encontre uma vez, reutilize.
Segurança: FilteringEnabled e validações
Segurança é absolutamente crítica no Roblox. FilteringEnabled (agora sempre ativo) separa cliente de servidor, impedindo que hackers manipulem o jogo
diretamente. Compreender e implementar validações adequadas protege a integridade do seu jogo e a experiência de jogadores honestos.
-- LocalScript
local botao = script.Parent
botao.MouseButton1Click:Connect(function()
-- NUNCA faça isso no cliente!
local jogador = game.Players.LocalPlayer
jogador.leaderstats.Moedas.Value += 1000
-- Hackers podem modificar este valor livremente
end)
o
Inseguro (Cliente)
Exploiters podem modificar qualquer LocalScript, concedendo moedas
infinitas, itens gratuitos, ou vantagens injustas.
-- ServerScript
local remoteEvent = game.ReplicatedStorage.ComprarItem
remoteEvent.OnServerEvent:Connect(function(jogador, itemId)
-- Validar no servidor SEMPRE
local preco = tabelaPrecos[itemId]
if not preco then
warn("Item inválido!")
return
end
local moedas = jogador.leaderstats.Moedas.Value
if moedas >= preco then
jogador.leaderstats.Moedas.Value -= preco
-- Conceder item
else
warn(jogador.Name .. " tentou comprar sem moedas!")
end
end)
'
Seguro (Servidor)
Servidor valida todas as ações críticas. Impossível de hackear.
Regra de Ouro
Nunca confie no cliente para validações
críticas
Valide tudo
Verifique permissões, valores, e limites no
servidor
Rate limiting
Previna spam limitando frequência de
ações
PĀb«caµj¾ ìpĀ áä³pä¾ ¥¾¾
Transformar seu projeto em um jogo público no Roblox é emocionante! Publicar é simples, mas existem passos importantes para garantir que seu jogo
esteja pronto, otimizado e apresentável para o público mundial.
01

Jogue múltiplas vezes, teste com amigos, busque bugs, verifique
performance em dispositivos diversos
02

Nome atrativo, descrição clara, ícone profissional, thumbnails chamativas,
tags apropriadas
03

Remova prints desnecessários, otimize scripts, teste em dispositivos
móveis e computadores fracos
04

File > Publish to Roblox, escolha se será público ou privado, configure
permissões
05

Adicione gamepasses, developer products, defina preços justos
06

Compartilhe com amigos, use social media, considere anúncios
patrocinados do Roblox
Lembre-se: publicar é apenas o começo. Jogos de sucesso recebem atualizações constantes, escutam feedback da comunidade e evoluem
continuamente.
M¾µpøĨafã¾ p Dpėp«¾ápä Pä¾jĀcøì
Monetizar seu jogo transforma hobby em potencial carreira. O Roblox oferece múltiplas formas de ganhar Robux através do seu jogo, que podem ser
convertidos em dinheiro real através do Developer Exchange (DevEx).
Ga³páaììpì
Benefícios permanentes únicos. Exemplos: VIP
status, acesso a áreas exclusivas, skins
especiais, velocidade aumentada. Preço
sugerido: 100-500 Robux.
Dpėp«¾ápä Pä¾jĀcøì
Itens consumíveis compráveis repetidamente.
Exemplos: moeda virtual, vidas extras, power-ups
temporários. Preço sugerido: 10-200 Robux.
Päėaøp Späėpäì
Servidores privados para grupos de amigos.
Configure preço mensal (recomendado: 100-200
Robux/mês). Renda recorrente passiva.
40%
Taĝa j¾ R¾b«¾ĝ
Roblox fica com 30% das transações, você
recebe 70%
$350
Mµ³¾ DpėEĝ
Necessário 30.000 Robux ($105) para converter
em dólares
1M+
T¾á Dpėp«¾ápäì
Desenvolvedores de sucesso ganham milhões
anualmente
Pä¿ĝ³¾ì áaìì¾ì: äpcĀäì¾ì aėaµfaj¾ì
Você dominou os fundamentos! Agora é hora de explorar sistemas avançados que diferenciam jogos profissionais de projetos amadores. Estas áreas
expandem dramaticamente o que é possível criar no Roblox.
Sìøp³aì MĀ«øá«aĞpä Aėaµfaj¾ì
Matchmaking, lobbies, sistemas de partido, sincronização de estado
complexa entre jogadores
Iµøp«uµca Aäøca«
Comportamentos de NPC sofisticados, máquinas de estado, árvores
de decisão, inimigos adaptativos
Sìøp³aì jp Daj¾ì C¾³á«pĝ¾ì
OrderedDataStores, sistema de clãs/guildas, economia persistente,
rankings globais
Sìøp³aì jp C¾³baøp
Hitboxes precisas, combos, habilidades especiais, balanceamento de
classes
HTTP Späėcp
Integração com APIs externas, webhooks Discord, sistemas de login
externos
Aµ³afÜpì Ppäì¾µa«Ĩajaì
Animation Editor, criar animações únicas, sistemas de animação
procedural

Parabéns por completar esta jornada intensiva através da programação Lua e desenvolvimento no Roblox! Você agora possui fundações sólidas para
criar praticamente qualquer tipo de experiência no Roblox. Mas lembre-se: este é apenas o começo.

Fundamentos completos de Lua
Arquitetura cliente-servidor
Scripts, eventos e comunicação
Sistemas de UI profissionais
Física e movimentação 3D
Persistência de dados
Monetização e publicação
Boas práticas e segurança

Roblox Developer Hub: Documentação oficial completa
DevForum: Comunidade de desenvolvedores
YouTube: Tutoriais em vídeo avançados
Roblox Creator Hub: Cursos estruturados
GitHub: Projetos open-source para estudar
Discord: Comunidades de desenvolvedores
"A melhor forma de aprender programação é praticando. Comece pequeno, publique cedo, itere constantemente, e nunca pare de aprender. Cada jogo
que você cria, por mais simples que seja, é um passo em direção à maestria."
Agora é sua vez de criar! Pegue essas ferramentas, combine com sua criatividade única, e construa experiências que milhões de jogadores ao redor do
mundo vão amar. O futuro do desenvolvimento de jogos está em suas mãos. Boa sorte, desenvolvedor!
Sobre a Obra
Este conteúdo foi desenvolvido com o auxílio de Inteligência Artificial, passando por um rigoroso processo de edição e revisão humana para garantir
máxima qualidade e precisão das informações apresentadas.
A ideia é proporcionar aqueles que buscam conhecimento através de um resumo claro e objetivo sobre o tema, contudo, a nossa visão poderá divergir e
até mesmo se opor a obra especificada. De qualquer modo, a nossa missão é despertar o interesse no aprofundamento sobre tal tema e a busca por
recursos complementares noutras obras pertinentes.
As imagens utilizadas são exclusivamente ilustrativas, selecionadas com propósito didático, e seus direitos autorais pertencem aos respectivos
proprietários. As imagens podem não representar fielmente os personagens, eventos ou situações descritas.
Este material pode ser livremente reinterpretado, integral ou parcialmente, desde que citada a fonte e mantida a referência ao Canal.
12/2025 - 2139