Resumo
Um jogo de tower defense no Roblox é um caminho de waypoints, inimigos que o servidor move por ele, torres que os jogadores colocam com dinheiro e que escolhem um alvo ao alcance, e um loop de waves que paga dinheiro por kill e fica mais difícil a cada rodada. Construa primeiro um mapa com três torres e cinco waves, balanceie em co-op, depois adicione desbloqueio de torres, mais mapas e modos. Se as torres são desbloqueadas por summons aleatórios comprados com Robux ou com moeda paga, você precisa mostrar as chances antes da compra.
- Faça toda checagem no servidor: dinheiro, local da torre, upgrades e dano. O cliente só pede.
- Dê a cada torre uma função (alvo único, dano em área, lentidão, detecção, dinheiro) e crie waves que precisem de cada função.
- Mire por padrão no inimigo que andou mais pelo caminho ("first"), e deixe os jogadores trocarem o modo.
Nesta página
O que faz um jogo de tower defense funcionar
O loop em uma linha: colocar torres, assistir à wave, ganhar dinheiro, fazer upgrade, sobreviver à próxima wave. A Roblox descreve o subgênero Tower Defense (dentro de Strategy) como jogos em que os jogadores posicionam unidades de defesa ao longo de um caminho para impedir que waves de inimigos cheguem ao fim dele. A parte interessante está no "estrategicamente".
- A cada 10 segundos: uma pequena decisão. Juntar para o upgrade ou colocar mais uma torre barata agora? Vender a torre que ficou no lugar errado?
- A cada wave: uma pergunta. Uma wave rápida, uma wave blindada, uma wave escondida, um chefe. Cada uma pergunta se a sua defesa cobre aquilo. Quando a resposta é não, o jogador aprende algo.
- A cada partida: um plano. O mapa, a dificuldade e as torres que você levou decidem a estratégia. Uma partida que termina em uma vitória apertada é a que os jogadores lembram.
- A cada sessão: progresso. Desbloquear uma torre nova ou vencer um modo mais difícil. Uma estrutura comum é um lobby em que os jogadores escolhem um loadout de torres antes de cada partida.
- Co-op. Vários jogadores defendendo um caminho, cada um colocando as próprias torres, transforma estratégia em conversa. As regras de dinheiro compartilhado (cada jogador ganha o seu, ou uma divisão) definem o quanto uma partida parece amigável.
Jogos de tower defense que são abandonados costumam ter uma torre dominante que deixa as outras sem sentido, waves que só crescem em vida e fazem toda partida ser igual, ou um caminho tão curto que o lugar das torres quase não importa. Se spammar uma torre vence, o jogo está resolvido e os jogadores vão embora.
Caminhos, funções das torres e tipos de inimigo
Planeje estes três juntos, porque cada um só importa em relação aos outros.
| Função da torre | O que faz | Inimigo que precisa dela |
|---|---|---|
| Alvo único | Muito dano em um inimigo, boa contra chefes | Chefes e inimigos blindados com muita vida |
| Dano em área | Causa dano a um grupo em volta do alvo | Enxames de inimigos fracos e rápidos |
| Lentidão ou congelamento | Deixa os inimigos lentos para as outras torres acertarem mais vezes | Inimigos rápidos que escapam |
| Detecção | Deixa as torres verem inimigos escondidos | Inimigos escondidos que ignoram torres sem detecção |
| Dinheiro | Ganha dinheiro a cada wave no lugar de atacar | Nenhum diretamente: troca segurança agora por força depois |
| Suporte | Aumenta o alcance ou a cadência de tiro das torres próximas | Waves finais em que só dano não basta |
Caminhos: um caminho longo com curvas dá às torres mais tempo em cada inimigo e dá aos jogadores escolhas reais sobre onde ficar. Cantos são zonas de kill naturais, porque uma torre perto de um canto cobre dois trechos do caminho. Um mapa com dois caminhos que se juntam obriga os jogadores a dividir a defesa. Marque onde as torres podem e não podem ficar (no caminho, dentro de paredes) e garanta isso no servidor.
Waves: alterne a pergunta. Uma boa sequência inicial é uma wave básica, uma wave rápida, uma wave em grupo e depois um primeiro chefe. Mantenha uma tabela com a quantidade de inimigos, a vida e a velocidade de cada wave em um ModuleScript, para balancear editando números, não código.
Os sistemas que um jogo de tower defense precisa
| Sistema | O que faz | Peças do Roblox | Guia |
|---|---|---|---|
| Caminho e movimento dos inimigos | Move os inimigos pelos waypoints e causa dano à base no final | Parts como waypoints, RunService.Heartbeat, CFrame | Esta página |
| Mira das torres | Escolhe um alvo ao alcance e causa dano com cooldown | Tags do CollectionService, atributos | Esta página |
| Colocação | Deixa os jogadores colocarem torres só em chão válido que eles podem pagar | RemoteFunction, workspace:GetPartBoundsInBox | RemoteEvents (em inglês) |
| Dinheiro e upgrades | Dinheiro por kill, preços de upgrade e de venda | leaderstats, checagens no servidor | Loja com GUI |
| Waves | Quantidade de inimigos, vida e velocidade por wave, tempo de construção entre elas | Configuração em ModuleScript, loop no servidor | Esta página |
| Lobby e partidas | Escolher um mapa e um loadout, depois mandar o grupo para uma partida | Teleportes, servidores reservados | Teleportes (em inglês) |
| Desbloqueio de torres e salvamento | Quais torres um jogador tem e o loadout dele | DataStoreService | Data stores |
| Inventário e loadout | Escolher quais torres levar | GUI, lista salva | Inventário |
| Leaderboard | Wave mais alta ou vitórias | Ordered data store | Leaderboard |
A colocação é onde jogos de tower defense são explorados. O cliente mostra uma torre fantasma embaixo do mouse e envia a posição. O servidor confere se o jogador tem o dinheiro, se o local está em uma área válida de colocação, se está dentro do mapa, e se não há já uma torre ou o caminho ali. Uma consulta de caixa com workspace:GetPartBoundsInBox no local pedido acha qualquer coisa no caminho; repare que ela testa caixas delimitadoras, então torres redondas contam como caixas.
Plano de construção: de uma baseplate ao lançamento
- O caminho. Uma pasta
Waypointscom parts chamadas 1, 2, 3 e assim por diante ao longo de uma estrada sinuosa, a primeira no spawn dos inimigos e a última na sua base. Deixe as parts invisíveis e sem colisão quando funcionar. - Inimigos e waves. Adicione o módulo Enemies e o script Waves. Veja três waves andarem pelo caminho e drenarem a base.
- Torres. Coloque três parts de torre à mão, marque com a tag
Tower, defina os atributos Range, Damage e Cooldown e adicione o script Towers. Ajuste os números até a wave 3 ser quase uma derrota. - Colocação e dinheiro. Um valor Cash no leaderstats, uma barra de torres na tela, uma prévia fantasma no cliente e uma função no servidor que valida e coloca a torre. Defina o atributo
OwnerIdde cada torre colocada como o UserId do jogador, para as kills pagarem a ele. - Greybox jogável: 3 torres, 10 waves, um mapa. Jogue sozinho e com dois amigos. Se alguém vence sem mudar de estratégia, alguma torre está forte demais.
- Upgrades e venda. Cada torre ganha dois ou três níveis de upgrade que aumentam os números dela ou mudam a função dela. Vender devolve parte do custo, então os erros têm conserto.
- Lobby, loadouts e salvamento. Um lobby para escolher torres e um mapa, partidas em servidores separados e desbloqueios de torres salvos.
- Recursos de lançamento. Barras de vida nos inimigos, um contador de waves e um timer, uma wave de chefe com barra de vida, um segundo mapa ou dificuldade, e um ou dois passes.
Inimigos que andam pelo caminho
Aqui os inimigos são parts ancoradas movidas pelo servidor, não personagens com Humanoids. O servidor guarda quanto cada um andou em studs, que é exatamente o número que as torres precisam para decidir quem é o "first". Um ModuleScript guarda a lista, para os scripts de torres e de waves lerem os mesmos inimigos.
-- ModuleScript no ServerScriptService chamado Enemies.
-- Move cada inimigo pelas parts numeradas em Workspace.Waypoints e
-- mantém a lista que as torres leem. Dar require nele inicia o movimento.
local RunService = game:GetService("RunService")
export type Enemy = { part: BasePart, health: number, speed: number, distance: number, reward: number }
local Enemies = { alive = {} :: { Enemy }, baseHealth = 100 }
local folder = workspace:WaitForChild("Waypoints") :: Folder
local points: { Vector3 } = {}
for i = 1, #folder:GetChildren() do
local p = folder:WaitForChild(tostring(i)) :: BasePart
points[i] = p.Position
end
-- Onde um inimigo está depois de andar tantos studs pelo caminho (nil = no final)
local function placeAt(distance: number): CFrame?
for i = 1, #points - 1 do
local a, b = points[i], points[i + 1]
local length = (b - a).Magnitude
if distance < length then
return CFrame.lookAt(a:Lerp(b, distance / length), b)
end
distance -= length
end
return nil
end
function Enemies.spawn(health: number, speed: number, reward: number)
local part = Instance.new("Part")
part.Size = Vector3.new(2, 2, 2)
part.Anchored = true
part.CanCollide = false
part.CFrame = CFrame.new(points[1])
part.Parent = workspace
local enemy: Enemy = { part = part :: BasePart, health = health, speed = speed, distance = 0, reward = reward }
table.insert(Enemies.alive, enemy)
end
RunService.Heartbeat:Connect(function(dt)
for i = #Enemies.alive, 1, -1 do
local enemy = Enemies.alive[i]
enemy.distance += enemy.speed * dt
local cframe = if enemy.health > 0 then placeAt(enemy.distance) else nil
if cframe then
enemy.part.CFrame = cframe
else
if enemy.health > 0 then -- chegou ao final: causa dano à base
Enemies.baseHealth = math.max(0, Enemies.baseHealth - enemy.health)
workspace:SetAttribute("BaseHealth", Enemies.baseHealth)
end
enemy.part:Destroy()
table.remove(Enemies.alive, i)
end
end
end)
return Enemies
- O
placeAtpercorre os trechos entre os waypoints e devolve a posição e a direção para uma certa distância. Quando a distância passa do último waypoint, o inimigo chegou à base e a vida que sobrou nele é tirada da base. - Troque depois o bloco provisório pelo seu próprio model de inimigo e mova-o com
PivotTono lugar de definir oCFrame. - Isto move todos os inimigos no servidor, a versão mais simples de acertar. Se você planeja waves muito grandes, teste cedo com a sua maior wave em um servidor de verdade e acompanhe o desempenho antes de adicionar mais.
Torres que miram no primeiro inimigo ao alcance
Cada torre confere dez vezes por segundo. Se o cooldown dela acabou, ela olha todos os inimigos dentro do alcance e escolhe o que andou a maior distância. Esse é o modo de mira "first", um padrão comum no gênero.
-- Script no ServerScriptService chamado Towers.
-- Cada part com a tag Tower atira no inimigo ao alcance que está mais adiante no caminho.
-- Os stats da torre são atributos: Range, Damage, Cooldown, OwnerId.
local CollectionService = game:GetService("CollectionService")
local Players = game:GetService("Players")
local ServerScriptService = game:GetService("ServerScriptService")
type Enemy = { part: BasePart, health: number, speed: number, distance: number, reward: number }
type EnemiesModule = { alive: { Enemy }, baseHealth: number, spawn: (number, number, number) -> () }
local Enemies = require(ServerScriptService:WaitForChild("Enemies")) :: EnemiesModule
local lastShot: { [Instance]: number } = {}
local function num(tower: Instance, name: string, default: number): number
local value = tower:GetAttribute(name)
return if typeof(value) == "number" then value else default
end
local function payOwner(tower: Instance, amount: number)
local owner = Players:GetPlayerByUserId(num(tower, "OwnerId", 0))
local leaderstats = owner and owner:FindFirstChild("leaderstats")
local cash = leaderstats and leaderstats:FindFirstChild("Cash")
if cash and cash:IsA("IntValue") then
cash.Value += amount
end
end
while true do
task.wait(0.1)
for _, tower in CollectionService:GetTagged("Tower") do
if not tower:IsA("BasePart") or os.clock() - (lastShot[tower] or 0) < num(tower, "Cooldown", 1) then
continue
end
local target: Enemy? = nil
for _, enemy in Enemies.alive do -- "first": o que andou mais
local inRange = (enemy.part.Position - tower.Position).Magnitude <= num(tower, "Range", 20)
if inRange and enemy.health > 0 and (not target or enemy.distance > target.distance) then
target = enemy
end
end
if target then
lastShot[tower] = os.clock()
target.health -= num(tower, "Damage", 5)
if target.health <= 0 then
payOwner(tower, target.reward)
end
end
end
end
- Outros modos de mira estão a uma comparação de distância: "last" escolhe a menor distância, "strongest" a maior vida, "closest" a menor distância até a torre. Guarde o modo em outro atributo e deixe os jogadores trocarem.
- O dano é aplicado no servidor, então um cliente não consegue fingir uma kill. Adicione um efeito visual nos clientes (um raio ou um projétil) disparando um RemoteEvent para todos os jogadores com as posições da torre e do alvo.
- Torres de dano em área causam dano a todo inimigo em um raio pequeno em volta do alvo. Torres de lentidão diminuem a
speedde um inimigo por alguns segundos. As duas são poucas linhas neste loop.
O loop de waves
-- Script no ServerScriptService chamado Waves.
-- Manda cada wave, espera ela ser limpa, depois dá tempo aos jogadores para construir.
local ServerScriptService = game:GetService("ServerScriptService")
type EnemiesModule = { alive: { any }, baseHealth: number, spawn: (number, number, number) -> () }
local Enemies = require(ServerScriptService:WaitForChild("Enemies")) :: EnemiesModule
local WAVES = { -- quantidade, vida, velocidade (studs por segundo), dinheiro por kill
{ count = 8, health = 10, speed = 6, reward = 5 },
{ count = 12, health = 18, speed = 7, reward = 6 },
{ count = 6, health = 80, speed = 4, reward = 25 }, -- uma wave lenta e resistente
}
for wave, info in WAVES do
workspace:SetAttribute("Wave", wave)
for _ = 1, info.count do
Enemies.spawn(info.health, info.speed, info.reward)
task.wait(1)
end
repeat
task.wait(0.5)
until #Enemies.alive == 0 or Enemies.baseHealth <= 0
if Enemies.baseHealth <= 0 then
break
end
task.wait(5) -- tempo de construção entre as waves
end
A terceira wave é mais lenta e bem mais resistente que a segunda: uma pergunta diferente, não só números maiores. Mostre Wave e BaseHealth dos atributos do Workspace em um HUD e, quando BaseHealth chegar a 0, termine a partida e mande os jogadores de volta ao lobby.
Monetização que combina com tower defense
Jogadores de tower defense aceitam pagar por torres, conveniência e visual. O limite é passado quando a estratégia mais forte do jogo só pode ser comprada, principalmente em co-op, onde a compra de um jogador muda a partida de todo mundo.
| Item | Recurso do Roblox | Aceito? | Cuidado com |
|---|---|---|---|
| Desbloqueio de torre comprado direto | Pass ou developer product | Sim, se for uma alternativa equivalente | Uma torre paga que vence todas as grátis deixa o jogo pay to win. |
| Summons aleatórios de torres | Developer product ou moeda paga | Comum, com regras | Itens aleatórios pagos: mostre as chances de cada resultado em porcentagens que somam 100 antes da compra. Veja abaixo. |
| Velocidade do jogo 2x | Pass | Sim, no solo | Em co-op ela acelera a partida de todo mundo. Deixe o host decidir, ou exija que todos os jogadores concordem. |
| Slot extra de loadout | Pass | Sim | Mais torres por partida é poder de verdade; mantenha o número grátis jogável. |
| Skins e efeitos de torres | Pass ou developer product | Sim | Nada: eles não mudam nenhum número. |
| Servidor privado | Servidores privados | Sim | Grupos podem usar para jogar os modos difíceis juntos. |
| Battle pass | Assinatura ou pass | Sim | O Roblox permite vender battle passes como assinatura. As recompensas devem ser cosméticos ou desbloqueios, não a torre mais forte. |
O que faz os jogadores de tower defense voltarem
- Torres novas. Cada atualização adiciona uma torre que abre uma nova estratégia, mais um tipo de inimigo que recompensa quem a usa.
- Níveis de dificuldade e modo infinito. O mesmo mapa em modos mais difíceis é conteúdo barato. Um modo infinito com um leaderboard da wave mais alta dá aos jogadores fortes uma meta de longo prazo.
- Eventos. Um mapa ou um conjunto de inimigos por tempo limitado, por algumas semanas, com uma recompensa que mostra que você estava lá.
- Coleção. Um índice de torres com silhuetas bloqueadas mostra aos jogadores o que falta desbloquear.
- Missões diárias. "Vença com uma torre de lentidão" ou "passe da wave 20 no difícil" empurra os jogadores a tentar estratégias que eles pulariam.
Crie com o RoCode
O RoCode é um agente de IA independente para Roblox Studio, não feito pela Roblox. Você descreve o jogo em um chat na web e o plugin dele para o Studio escreve o Luau e constrói parts, scripts e UI no jogo que você tem aberto. Para tower defense, ele pode construir o caminho, os scripts de inimigos e de torres, as checagens de colocação e as tabelas de waves, e adicionar um HUD, uma loja ou um timer de rodada dos kits de UI dele. Ele não consegue fazer meshes nem animações de torres ou inimigos, e o balanceamento ainda precisa dos seus testes.
Faça a primeira versão jogável de um jogo de tower defense no meu jogo: um caminho sinuoso de parts de waypoint numeradas, inimigos que o servidor move por ele, 3 torres com alcance, dano e cooldown que miram no primeiro inimigo ao alcance, dinheiro por kill no leaderstats, 10 waves que alternam inimigos rápidos, resistentes e em grupo, e uma vida da base que termina a partida em 0.
- Escreve os scripts de inimigos, torres, waves e colocação com toda checagem no servidor
- Constrói o caminho e um mapa greybox, depois adiciona recursos em rodadas: upgrades, venda, um lobby
- Pode adicionar telas dos kits de UI, como um HUD, um timer de rodada, uma loja e uma loja de game passes
- Pode rodar um robô de teste que clica nos botões e informa PASS ou FAIL sobre o que conferiu
O RoCode não publica o jogo, não cria passes nem produtos no Creator Hub, e não gasta Robux. O plano grátis dá créditos grátis todo dia, sem cartão. Como o RoCode constrói um jogo.
Perguntas frequentes
Como fazer inimigos seguirem um caminho no Roblox?
Coloque parts numeradas ao longo do caminho e mova cada inimigo de uma para a próxima no servidor, guardando quanto ele já andou. O módulo Enemies acima faz isso para todos os inimigos em um loop só.
Como as torres escolhem em qual inimigo atirar?
Cada torre olha os inimigos dentro do alcance e escolhe um por uma regra. "First" (o inimigo mais adiante no caminho) é um padrão comum; "last", "strongest" e "closest" são modos extras comuns.
Como impedir que os jogadores coloquem torres no caminho?
Confira no servidor, não só na prévia de colocação. Quando um jogador pede para colocar uma torre, o servidor confere se o local está em uma área válida de colocação e faz uma consulta de caixa ali para achar qualquer part do caminho ou torre que já esteja no lugar.
Preciso mostrar as chances dos summons de torres?
Sim, se os jogadores pagam Robux, ou moeda comprada com Robux, por uma torre aleatória. A política de itens aleatórios pagos do Roblox exige as chances de cada resultado antes da compra. Recompensas aleatórias grátis não precisam.
Quanto tempo leva para fazer um jogo de tower defense?
Um greybox com um mapa, três torres e dez waves leva alguns dias de trabalho para quem já sabe Luau. Um jogo pronto para lançar, com lobby, desbloqueios, upgrades e modos balanceados, leva bem mais tempo, principalmente no balanceamento.
Fontes e leitura extra
- Roblox Creator Docs: Genres (em inglês). o subgênero Tower Defense dentro de Strategy
- Roblox Creator Docs: Paid random items policy (em inglês). divulgação das chances e ArePaidRandomItemsRestricted
- Roblox Engine API: WorldRoot:GetPartBoundsInBox (em inglês). consultas de caixa usam caixas delimitadoras
- Roblox Engine API: CollectionService (em inglês). tags
- Roblox Creator Docs: Passes (em inglês). compras únicas
- Roblox Creator Docs: Subscriptions (em inglês). battle passes como assinaturas
- Guia do RoCode: RemoteEvents (em inglês). as checagens que o servidor precisa fazer nos pedidos do cliente
Como o código foi verificado: todo script desta página passa no verificador de tipos estrito do Luau com as definições da API do Roblox (luau-lsp, 12 de novembro de 2026). A verificação de tipos pega APIs com nome errado e tipos incorretos, não a lógica do jogo, então teste no Studio antes de publicar.