Gêneros de jogo

Como fazer um jogo de tower defense no Roblox Studio

Tower defense parece simples: inimigos andam por um caminho, torres atiram neles. O que faz um jogo valer a pena jogar de novo e outro ser esquecido é tudo em volta disso: um caminho com escolhas de verdade, torres com funções claras, waves que fazem perguntas que as suas torres atuais não respondem, e uma economia que transforma cada torre colocada em uma decisão. Este guia cobre o design, os sistemas, um plano de construção, código de servidor para inimigos em waypoints e torres que miram no primeiro inimigo ao alcance, e como monetizar o desbloqueio de torres sem quebrar as regras do Roblox sobre itens aleatórios pagos.

Atualizado em 12 de novembro de 202611 min de leituraEscrito por

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
  1. O que faz funcionar
  2. Design
  3. Sistemas
  4. Plano de construção
  5. Script dos inimigos
  6. Script das torres
  7. Script das waves
  8. Monetização
  9. Retenção
  10. Com o RoCode
  11. Perguntas frequentes
  12. Fontes e leitura extra

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ções das torres e o inimigo que torna cada função necessária
Função da torreO que fazInimigo que precisa dela
Alvo únicoMuito dano em um inimigo, boa contra chefesChefes e inimigos blindados com muita vida
Dano em áreaCausa dano a um grupo em volta do alvoEnxames de inimigos fracos e rápidos
Lentidão ou congelamentoDeixa os inimigos lentos para as outras torres acertarem mais vezesInimigos rápidos que escapam
DetecçãoDeixa as torres verem inimigos escondidosInimigos escondidos que ignoram torres sem detecção
DinheiroGanha dinheiro a cada wave no lugar de atacarNenhum diretamente: troca segurança agora por força depois
SuporteAumenta o alcance ou a cadência de tiro das torres próximasWaves 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

Sistemas, as peças do Roblox que eles usam, e onde aprender cada um
SistemaO que fazPeças do RobloxGuia
Caminho e movimento dos inimigosMove os inimigos pelos waypoints e causa dano à base no finalParts como waypoints, RunService.Heartbeat, CFrameEsta página
Mira das torresEscolhe um alvo ao alcance e causa dano com cooldownTags do CollectionService, atributosEsta página
ColocaçãoDeixa os jogadores colocarem torres só em chão válido que eles podem pagarRemoteFunction, workspace:GetPartBoundsInBoxRemoteEvents (em inglês)
Dinheiro e upgradesDinheiro por kill, preços de upgrade e de vendaleaderstats, checagens no servidorLoja com GUI
WavesQuantidade de inimigos, vida e velocidade por wave, tempo de construção entre elasConfiguração em ModuleScript, loop no servidorEsta página
Lobby e partidasEscolher um mapa e um loadout, depois mandar o grupo para uma partidaTeleportes, servidores reservadosTeleportes (em inglês)
Desbloqueio de torres e salvamentoQuais torres um jogador tem e o loadout deleDataStoreServiceData stores
Inventário e loadoutEscolher quais torres levarGUI, lista salvaInventário
LeaderboardWave mais alta ou vitóriasOrdered data storeLeaderboard

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

  1. O caminho. Uma pasta Waypoints com 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.
  2. Inimigos e waves. Adicione o módulo Enemies e o script Waves. Veja três waves andarem pelo caminho e drenarem a base.
  3. 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.
  4. 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 OwnerId de cada torre colocada como o UserId do jogador, para as kills pagarem a ele.
  5. 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.
  6. 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.
  7. Lobby, loadouts e salvamento. Um lobby para escolher torres e um mapa, partidas em servidores separados e desbloqueios de torres salvos.
  8. 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 em ServerScriptService chamado Enemies
-- 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 placeAt percorre 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 PivotTo no lugar de definir o CFrame.
  • 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 em ServerScriptService chamado Towers
-- 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 speed de um inimigo por alguns segundos. As duas são poucas linhas neste loop.

O loop de waves

Script em ServerScriptService chamado 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.

O que combina com um jogo de tower defense, e a armadilha de cada um
ItemRecurso do RobloxAceito?Cuidado com
Desbloqueio de torre comprado diretoPass ou developer productSim, se for uma alternativa equivalenteUma torre paga que vence todas as grátis deixa o jogo pay to win.
Summons aleatórios de torresDeveloper product ou moeda pagaComum, com regrasItens aleatórios pagos: mostre as chances de cada resultado em porcentagens que somam 100 antes da compra. Veja abaixo.
Velocidade do jogo 2xPassSim, no soloEm co-op ela acelera a partida de todo mundo. Deixe o host decidir, ou exija que todos os jogadores concordem.
Slot extra de loadoutPassSimMais torres por partida é poder de verdade; mantenha o número grátis jogável.
Skins e efeitos de torresPass ou developer productSimNada: eles não mudam nenhum número.
Servidor privadoServidores privadosSimGrupos podem usar para jogar os modos difíceis juntos.
Battle passAssinatura ou passSimO 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.
Captura de tela de um teste no Roblox Studio: uma tela de loja no tema gold com itens e preços.
Captura do Studio. A tela de loja dos kits de UI do RoCode (tema gold), em um teste no Studio. É uma tela de kit que o RoCode pode adicionar, por exemplo como loja de torres, não parte de um jogo construído neste guia.

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.

Você digita

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.

O RoCode faz
  • 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

Criar no Studio

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

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.

Teste o RoCode no seu próprio jogo.

Créditos grátis todo dia, sem cartão. Instale o plugin, descreva o recurso e confira o que aparece no Studio.