Tutorial · Sistemas de jogo

Como fazer uma espada no Roblox Studio

Uma espada no Roblox é uma Tool com três tarefas divididas entre dois scripts: o dispositivo do jogador percebe o clique e toca o golpe, e o servidor decide quem foi atingido e quanta vida perde. Este guia monta os dois, com um cooldown e uma hitbox que os jogadores não conseguem falsificar, e mostra onde entra uma animação.

Atualizado em 12 de novembro de 202626 min de leituraEscrito por

Resumo

Coloque no StarterPack uma Tool chamada Sword com uma part chamada Handle. Um LocalScript na Tool escuta o Tool.Activated, toca a animação do golpe e dispara um RemoteEvent sem argumentos. Um Script no ServerScriptService confere o cooldown e se o jogador está vivo e segurando a espada, acha os Humanoids em uma caixa à frente dele com workspace:GetPartBoundsInBox e chama Humanoid:TakeDamage uma vez por alvo.

  • Não aplique dano pelo evento Touched da lâmina: o dispositivo do jogador controla o próprio personagem e pode disparar o Touched de qualquer lugar, e esse é o exemplo de espada que a página de network ownership da Roblox dá.
  • O cliente não envia alvo nem dano. O cooldown, a hitbox e o valor do dano pertencem ao servidor.
  • O TakeDamage não faz nada enquanto o alvo tem um ForceField, como nos 10 segundos depois de nascer em uma SpawnLocation.
  • Golpes que atravessam paredes, ou que acertam antes de o golpe parecer encostar? Use a versão com preparação e checagem de parede do script de servidor.
Nesta página
  1. Como se encaixa
  2. 1. Monte a Tool
  3. 2. Script do servidor
  4. 3. LocalScript
  5. A hitbox
  6. Métodos de hitbox
  7. Preparação e parede
  8. Animação de golpe
  9. Tutoriais antigos
  10. Limites contra exploits
  11. 4. Teste
  12. Indo além
  13. Erros comuns
  14. Com o RoCode
  15. Perguntas frequentes
  16. Fontes e leitura extra

Como as peças de uma espada se encaixam

IlustraçãoGolpes com pelo menos 0,6 segundo de intervalo tiram 20 de vida cada, um clique dentro do cooldown não faz nada, e o quinto acerto derruba o rig.

Uma espada que funciona em um jogo publicado é dividida entre o dispositivo do jogador e o servidor. A página de tools da Roblox diz que a entrada de uma tool pertence aos LocalScripts, porque só o dispositivo do jogador sabe quando a entrada acontece, e que a maioria das tools precisa de um LocalScript, um Script de servidor e um RemoteEvent entre eles. Este guia usa exatamente essa divisão. Um golpe acontece assim:

  1. O jogador clica, toca ou aperta o gatilho do controle com a Sword equipada. O Tool.Activated dispara no LocalScript.
  2. O LocalScript toca a animação do golpe, se houver uma, e dispara o RemoteEvent SwordSwing. Ele não envia mais nada.
  3. O Script do servidor confere o cooldown, se o jogador está vivo e se a Sword está na mão dele.
  4. O servidor monta a própria hitbox à frente do personagem do jogador e acha todo Humanoid dentro dela.
  5. Cada um desses Humanoids perde vida uma vez, pelo TakeDamage.
As peças da espada
PeçaOnde ficaO que faz
Tool SwordStarterPackO que o jogador segura. O Roblox copia tudo o que está no StarterPack para a Backpack do jogador toda vez que o personagem dele nasce.
Part HandleDentro da ToolA part que o personagem empunha. A lâmina é soldada a ela.
LocalScript SwordClientDentro da ToolEscuta o clique, toca a animação do golpe e dispara o remote.
RemoteEvent SwordSwingReplicatedStorage (o SwordService cria)Leva o "dei um golpe" do dispositivo do jogador ao servidor, sem argumentos.
Script SwordServiceServerScriptServiceConfere cada golpe, acha quem está à frente do jogador e aplica o dano. O único lugar em que um acerto pode acontecer.
O Explorer quando a espada está pronta. O SwordService adiciona um RemoteEvent chamado SwordSwing ao ReplicatedStorage quando o jogo roda.
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

Passo 1: Monte a Tool da espada

  1. No Explorer, passe o mouse sobre Workspace, clique no botão + e insira uma Tool. Renomeie para Sword. O script do servidor procura exatamente esse nome. Você monta a espada no Workspace, como sugere a página de tools da Roblox, porque é ali que dá para ver as parts dela, movê-las e redimensioná-las. O último passo a leva para o StarterPack.
  2. Insira uma Part na Tool e dê o nome Handle. Este é o cabo, por onde o personagem segura a espada. Ela precisa ser filha direta da Tool, e precisa ser a única part com esse nome: com dois Handles, o Roblox escolhe um ao acaso, e o personagem pode segurar a espada pela lâmina.
  3. Insira uma segunda Part na Tool, dê o nome Blade, e dê a ela forma e posição para sair pelo topo do Handle.
  4. Insira um WeldConstraint na Blade. Na janela Properties, defina o Part0 dele como Handle e o Part1 como Blade, para a espada ficar inteira enquanto o jogador a carrega.
  5. Selecione as duas parts e confira que Anchored está desligado. Uma part ancorada em uma tool prende o personagem no lugar quando ele a equipa. Desligue também o CanCollide das duas, para a lâmina não esbarrar em jogadores e paredes durante o golpe.
  6. Selecione a Tool e desmarque CanBeDropped. Quando está marcado, apertar Backspace larga a espada no Workspace.
  7. Arraste a Sword pronta do Workspace para o StarterPack. Uma Tool deixada no Workspace é um item que um jogador pega do chão, não uma espada que começa na Backpack de todo jogador.

Uma espada feita de uma única MeshPart também funciona: dê a essa MeshPart o nome Handle e pule o weld. Se o personagem segurar a espada em um ângulo estranho no teste, selecione a Tool e ajuste as propriedades de empunhadura dela (GripPos, GripForward, GripRight e GripUp) na janela Properties.

Passo 2: Adicione o script do servidor

Passe o mouse sobre ServerScriptService, insira um Script chamado SwordService e cole o código abaixo. Ele é o único lugar em que um golpe de espada pode acertar. As configurações no topo são as linhas feitas para você mudar.

Script em ServerScriptService chamado SwordService
-- Script no ServerScriptService chamado SwordService.
-- O único lugar em que um golpe de espada pode acontecer: ele confere o golpe, acha os alvos à frente
-- do atacante com a própria hitbox e aplica o dano.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Configurações
local SWORD_NAME = "Sword" -- o nome da Tool no StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- mantenha o mesmo valor no SwordClient
local HIT_RANGE = 6 -- studs à frente do atacante
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false: jogadores do mesmo time não conseguem se ferir
-- Golpes enviados com exatamente COOLDOWN_SECONDS de intervalo podem chegar um pouco mais juntos depois de um
-- atraso de rede, então o servidor permite esta folga em vez de descartar um golpe de verdade
local NETWORK_SLACK = 0.1

-- O remote que o LocalScript da espada dispara. Ele não leva argumentos: o servidor
-- decide quem é atingido, então não há nada para um cliente falsificar.
local swingEvent = Instance.new("RemoteEvent")
swingEvent.Name = "SwordSwing"
swingEvent.Parent = ReplicatedStorage

local lastSwing: { [Player]: number } = {}

local function isTeammate(attacker: Player, target: Player?): boolean
	if FRIENDLY_FIRE or not target then
		return false
	end
	-- Jogadores neutros (sem time) sempre conseguem se atingir
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

local function onSwing(player: Player)
	-- 1. Um golpe por cooldown, não importa quantas vezes o remote seja disparado
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end

	-- 2. O atacante precisa estar vivo e segurando a espada
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local rootPart = humanoid and humanoid.RootPart
	if not (character and humanoid and rootPart) or humanoid.Health <= 0 then
		return
	end
	local sword = character:FindFirstChild(SWORD_NAME)
	if not (sword and sword:IsA("Tool")) then
		return
	end
	lastSwing[player] = now

	-- 3. A hitbox do próprio servidor: uma caixa à frente da root part do atacante
	local params = OverlapParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { character }
	local boxCFrame = rootPart.CFrame * CFrame.new(0, 0, -HIT_RANGE / 2)
	local parts = workspace:GetPartBoundsInBox(boxCFrame, Vector3.new(HIT_WIDTH, HIT_HEIGHT, HIT_RANGE), params)

	-- 4. Aplica dano a cada Humanoid da caixa uma vez, mesmo que várias parts dele estejam dentro
	local alreadyHit: { [Humanoid]: boolean } = {}
	for _, part in parts do
		local model = part:FindFirstAncestorOfClass("Model")
		local target = model and model:FindFirstChildOfClass("Humanoid")
		if model and target and not alreadyHit[target] and target.Health > 0 then
			alreadyHit[target] = true
			if not isTeammate(player, Players:GetPlayerFromCharacter(model)) then
				target:TakeDamage(DAMAGE) -- não faz nada enquanto o alvo tem um ForceField
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(onSwing)

Players.PlayerRemoving:Connect(function(player: Player)
	lastSwing[player] = nil
end)

O próprio SwordService cria o RemoteEvent SwordSwing quando o jogo começa, então não há nada para inserir à mão no ReplicatedStorage. Se você já criou um RemoteEvent com esse nome, apague: o LocalScript poderia achar o seu, que ninguém no servidor escuta.

As configurações no topo do SwordService
ConfiguraçãoValor aquiO que muda
SWORD_NAME"Sword"O nome da Tool que o servidor espera na mão do jogador. Mude se a sua Tool tem outro nome.
DAMAGE20A vida que cada acerto tira. Um Humanoid começa com 100 de vida, então cinco acertos derrubam o rig de teste. Os personagens dos jogadores recuperam 1% do MaxHealth por segundo por padrão, então um jogador atingido na velocidade máxima de golpes sobrevive ao quinto acerto e precisa de um sexto.
COOLDOWN_SECONDS0.6O tempo entre golpes. Defina o mesmo valor no SwordClient.
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6A hitbox em studs: até onde ela alcança à frente do jogador, a largura e a altura.
FRIENDLY_FIREfalseQuando é false, jogadores do mesmo time não conseguem se ferir. Jogadores sem time sempre conseguem se atingir, e NPCs sempre podem ser atingidos.
NETWORK_SLACK0.1Quanto antes do fim do cooldown o servidor ainda aceita um golpe. Dois cliques com 0,6 segundo de intervalo podem chegar um pouco mais juntos depois de um atraso de rede, e sem essa folga o servidor descartaria um golpe de verdade que o jogador já viu.

Passo 3: Adicione o LocalScript na Tool

Insira um LocalScript na Tool Sword, dê o nome SwordClient e cole isto:

LocalScript em a Tool Sword no StarterPack chamado SwordClient
-- LocalScript dentro da Tool Sword, chamado SwordClient.
-- O Tool.Activated dispara no dispositivo do jogador, então este script escuta o clique,
-- o toque ou o gatilho, toca a animação do golpe e pede o golpe ao servidor.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local tool = script.Parent :: Tool
local swingEvent = ReplicatedStorage:WaitForChild("SwordSwing") :: RemoteEvent

local COOLDOWN_SECONDS = 0.6 -- o mesmo valor do SwordService
local SWING_ANIMATION_ID = "" -- opcional: "rbxassetid://" seguido do id da sua animação

local player = Players.LocalPlayer
local lastSwing = 0
local swingTrack: AnimationTrack? = nil
local trackCharacter: Model? = nil

-- Carrega a animação uma vez por personagem. Animações iniciadas no seu próprio personagem
-- a partir do seu dispositivo são mostradas a todos os jogadores.
local function loadSwing()
	local character = player.Character
	if SWING_ANIMATION_ID == "" or not character or character == trackCharacter then
		return
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	local animator = humanoid and humanoid:FindFirstChildOfClass("Animator")
	if animator then
		local animation = Instance.new("Animation")
		animation.AnimationId = SWING_ANIMATION_ID
		swingTrack = animator:LoadAnimation(animation)
		trackCharacter = character
	end
end

tool.Equipped:Connect(loadSwing)

tool.Activated:Connect(function()
	local now = os.clock()
	if now - lastSwing < COOLDOWN_SECONDS then
		return -- o servidor também impõe isso; conferir aqui evita pedidos desperdiçados
	end
	lastSwing = now
	if swingTrack then
		swingTrack:Play()
	end
	swingEvent:FireServer()
end)

Deixe o SWING_ANIMATION_ID vazio por enquanto. A espada funciona sem animação, porque o servidor decide o acerto de qualquer jeito. Adicione uma animação de golpe mostra como preencher.

O Activated dispara com um clique do mouse, um toque no celular e o gatilho de um controle, então o mesmo script funciona em todo dispositivo. O Roblox copia a Tool, e o LocalScript dentro dela, para a Backpack de cada jogador quando o personagem dele nasce, então cada jogador roda a própria cópia.

O LocalScript mantém o próprio cooldown só para não enviar pedidos que o servidor ignoraria de qualquer jeito. Não é uma checagem de segurança: um trapaceiro pode apagá-lo, editá-lo ou disparar o SwordSwing pelo próprio código. O guia de RemoteEvents explica por que todo remote precisa ser conferido no servidor, e Script vs LocalScript vs ModuleScript (em inglês) mostra o que um LocalScript consegue e não consegue mudar.

Como o servidor decide quem é atingido

Quando o SwordSwing chega, o SwordService não pergunta nada ao cliente. Ele monta uma caixa à frente do personagem do atacante, onde o servidor o enxerga, e pergunta ao motor quais parts estão dentro com workspace:GetPartBoundsInBox. Esse método substitui o antigo FindPartsInRegion3, que a Roblox marca como obsoleto.

A caixa fica centrada 3 studs à frente da root part do atacante. É esse o deslocamento CFrame.new(0, 0, -HIT_RANGE / 2): um CFrame olha ao longo do eixo Z negativo dele, o LookVector. Então a caixa vai do meio do personagem até 6 studs à frente, e tem 5 studs de largura e 6 de altura. A consulta compara a bounding box de cada part, uma aproximação rápida do volume dela em forma de caixa, então parts redondas e meshes contam como um pouco maiores do que parecem. Para uma espada, essa pequena margem ajuda.

O que o SwordService faz com as parts da caixa
PassoCódigoPor quê
Pular o atacanteOverlapParams com Exclude e o personagem do atacanteOs braços, as pernas e a espada do próprio atacante também estão dentro da caixa.
Achar o personagempart:FindFirstAncestorOfClass("Model")Uma part na caixa pode ser um membro, um chapéu ou uma tool na mão. O FindFirstAncestorOfClass compara o nome exato da classe, então passa por cima de um chapéu (classe Accessory) e de uma tool na mão (classe Tool, embora uma Tool seja um tipo de Model) e para no model do personagem.
Achar o Humanoidmodel:FindFirstChildOfClass("Humanoid")Tudo o que tem um Humanoid pode ser atingido: jogadores, NPCs e bonecos de teste. Paredes e pisos são pulados.
Uma vez por Humanoida tabela alreadyHitVárias parts de um personagem costumam estar na caixa. Sem a tabela, cada uma delas aplicaria o dano de novo.
Só alvos vivostarget.Health > 0Um personagem que já foi derrubado não é atingido de novo.
TimesisTeammateCom FRIENDLY_FIRE false, jogadores do mesmo time são pulados. Um jogador cuja propriedade Neutral é true não tem time.
Danotarget:TakeDamage(DAMAGE)Baixa a Health, a não ser que um ForceField proteja o alvo.

A tabela alreadyHit é criada do zero a cada golpe, então o mesmo jogador pode ser atingido de novo no golpe seguinte, depois que o cooldown passar. Essa é a regra de "uma vez por alvo por golpe" com que as espadas baseadas em Touched têm dificuldade.

O script usa TakeDamage em vez de definir a Health. A referência da Roblox diz que o TakeDamage deixa um Humanoid em paz enquanto um ForceField o protege, e que definir a Health diretamente ignora ForceFields. Um jogador que nasce em uma SpawnLocation ganha um ForceField por 10 segundos por padrão (a Duration da SpawnLocation), então quem acabou de chegar não pode ser atingido no instante em que aparece.

Quatro jeitos de fazer a hitbox de uma espada, comparados

Os tutoriais de espada discordam principalmente em uma coisa: como descobrir o que a lâmina acertou. Há quatro respostas comuns. Elas diferem em quanto acompanham a lâmina, quanto trabalho custam ao servidor, e se um trapaceiro consegue falsificar o resultado.

Métodos de hitbox de espada. "Quem decide" é o lado cuja resposta vale
MétodoComo funcionaQuem decidePrecisãoMelhor para
Touched na lâminaDano sempre que a part da lâmina toca em um personagemO dispositivo do atacante, que é dono do próprio personagem e da espadaAcompanha a lâmina, mas dispara várias vezes por contatoNada em um jogo com outros jogadores: o dispositivo do atacante pode dispará-lo de qualquer lugar
Uma caixa à frente do jogador (este guia)Uma consulta GetPartBoundsInBox no servidor por golpeO servidorUma caixa fixa, não o caminho da lâmina. Meshes contam pelas bounding boxes, então é um pouco generosaA maioria dos jogos: simples, barata e sem nada para falsificar
GetPartsInPart em uma part de hitboxUma consulta no servidor com uma part no formato da varredura da lâmina, durante o golpeO servidorFormas exatas: a documentação da Roblox diz que ele faz uma checagem geométrica completa, e sugere as consultas de caixa ou esfera quando menos precisão basta, porque são mais baratasArmas grandes com formas incomuns, como o arco de uma foice
Raycasts ao longo da lâminaA cada frame do golpe, lança raios curtos de pontos da lâmina até onde eles estavam no frame anteriorO lado que os lança. No servidor, precisa da ideia que o servidor tem de onde a lâmina estáAcompanha a animação de pertoJogos em que o caminho exato do golpe importa. Os módulos de hitbox da comunidade funcionam assim

A caixa é a primeira escolha certa. É uma consulta por golpe, nunca depende da animação que um trapaceiro poderia mudar, e é fácil de ajustar com três números. Troque por uma part com forma ou por raios na lâmina quando os jogadores reclamarem que os acertos parecem errados em uma arma cujo alcance está longe de ser uma caixa, e mantenha a mesma regra: o servidor roda a consulta e aplica o dano.

Presets de espada: da adaga ao espadão

O mesmo SwordService faz armas muito diferentes a partir de cinco configurações. A tabela é um ponto de partida, calculada contra um boneco do Rig Generator com 100 de Health. "Tempo para derrubar" conta a partir do primeiro acerto, com cada golpe acertando assim que o cooldown permite.

Configurações do SwordService para armas corpo a corpo comuns, com acertos e tempo para derrubar um boneco com 100 de Health. Calculado, não medido
ArmaDAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTHAcertos (tempo)Dano por segundo
Adaga120.35449 (2,8 s)cerca de 34
Espada (este guia)200.6655 (2,4 s)cerca de 33
Espadão351.1773 (2,2 s)cerca de 32
Lança180.8936 (4 s)cerca de 23
  • Jogadores se curam, bonecos não. Os personagens dos jogadores recuperam 1% do MaxHealth por segundo por padrão. Com exatamente 100 de dano em 5 acertos, um jogador atingido na velocidade máxima sobrevive ao quinto acerto e precisa de um sexto. Deixe uma margem, por exemplo 21 de dano em vez de 20, se um número fixo de acertos importa.
  • Ajuste o NETWORK_SLACK junto com o cooldown. O 0,1 segundo do guia é um sexto de 0,6. Deixado em 0.1 em uma adaga de 0,35 segundo, um trapaceiro poderia golpear a cada 0,25 segundo, 40% mais rápido. Use cerca de um sexto do COOLDOWN_SECONDS: 0.06 para a adaga.
  • Mantenha o SwordClient em sincronia. Defina lá o mesmo COOLDOWN_SECONDS, senão o cliente envia golpes que o servidor ignora.

Versão 2: preparação do golpe e nada de acertar através de paredes

Duas reclamações aparecem quando a espada básica já funciona. O golpe acerta no instante em que o jogador clica, antes de a animação chegar ao alvo, e um golpe pode alcançar alguém do outro lado de uma parede fina, porque a caixa ignora paredes. Esta versão do SwordService corrige as duas coisas. Ela substitui o script do Passo 2: mesmo nome, mesmo remote, mesmas configurações, então o SwordClient não precisa mudar.

Script em ServerScriptService chamado SwordService
-- Script no ServerScriptService chamado SwordService (a versão com preparação e checagem de parede).
-- Substitui o script do Passo 2: mesmas configurações e mesmo remote, mais duas regras. O golpe acerta
-- WINDUP_SECONDS depois do clique, quando o golpe chega ao alvo, e ninguém é atingido
-- através de uma parede.

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Configurações
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- mantenha o mesmo valor no SwordClient
local WINDUP_SECONDS = 0.15 -- tempo do clique até o acerto; ajuste à sua animação de golpe
local HIT_RANGE = 6
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false
local NETWORK_SLACK = 0.1

local swingEvent = Instance.new("RemoteEvent")
swingEvent.Name = "SwordSwing"
swingEvent.Parent = ReplicatedStorage

local lastSwing: { [Player]: number } = {}

local function isTeammate(attacker: Player, target: Player?): boolean
	if FRIENDLY_FIRE or not target then
		return false
	end
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

-- Retorna o personagem e a root part do atacante enquanto ele está vivo e segurando a espada
local function getArmedCharacter(player: Player): (Model?, BasePart?)
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local rootPart = humanoid and humanoid.RootPart
	if not (character and humanoid and rootPart) or humanoid.Health <= 0 then
		return nil, nil
	end
	local sword = character:FindFirstChild(SWORD_NAME)
	if not (sword and sword:IsA("Tool")) then
		return nil, nil
	end
	return character, rootPart
end

-- True quando nada além do alvo está entre o atacante e o alvo
local function hasClearLine(attacker: Model, from: BasePart, target: Model, to: BasePart): boolean
	local params = RaycastParams.new()
	params.ExcludeInstances = { attacker }
	local result = workspace:Raycast(from.Position, to.Position - from.Position, params)
	return result == nil or result.Instance:IsDescendantOf(target)
end

local function strike(player: Player)
	-- Conferido de novo depois da preparação: o atacante pode ter morrido ou guardado a espada
	local character, rootPart = getArmedCharacter(player)
	if not (character and rootPart) then
		return
	end
	local params = OverlapParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { character }
	local boxCFrame = rootPart.CFrame * CFrame.new(0, 0, -HIT_RANGE / 2)
	local parts = workspace:GetPartBoundsInBox(boxCFrame, Vector3.new(HIT_WIDTH, HIT_HEIGHT, HIT_RANGE), params)

	local alreadyHit: { [Humanoid]: boolean } = {}
	for _, part in parts do
		local model = part:FindFirstAncestorOfClass("Model")
		local target = model and model:FindFirstChildOfClass("Humanoid")
		local targetRoot = target and target.RootPart
		if model and target and targetRoot and not alreadyHit[target] and target.Health > 0 then
			alreadyHit[target] = true
			if not isTeammate(player, Players:GetPlayerFromCharacter(model)) and hasClearLine(character, rootPart, model, targetRoot) then
				target:TakeDamage(DAMAGE)
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(function(player: Player)
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end
	local character = getArmedCharacter(player)
	if not character then
		return
	end
	lastSwing[player] = now
	task.delay(WINDUP_SECONDS, strike, player)
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastSwing[player] = nil
end)

Apague antes o SwordService do Passo 2, senão cada um dos dois scripts cria um remote SwordSwing. Defina o WINDUP_SECONDS como o momento da sua animação de golpe em que a lâmina passa à frente do personagem; 0.15 serve para um golpe rápido.

  • A preparação. O cooldown e as checagens de "vivo e segurando a espada" rodam quando o clique chega, depois o task.delay roda o strike WINDUP_SECONDS mais tarde. O strike confere o atacante de novo, porque ele pode ter morrido ou guardado a espada nesse meio tempo, e só então monta a caixa. Um alvo que sai do alcance durante a preparação não é atingido, que é o que os jogadores esperam quando veem o golpe.
  • A checagem de parede. Para cada alvo na caixa, o hasClearLine lança um raio da root part do atacante até a root part do alvo, pulando o personagem do próprio atacante. Se a primeira coisa que ele encontra pertence ao alvo, ou se não encontra nada, o acerto vale. Uma parede, uma porta ou outro jogador no meio bloqueia.
  • Quanto custa. Um raio a mais por alvo por golpe, o que é pouco perto da própria consulta da caixa.

A preparação também deixa a espada mais justa contra trapaceiros que golpeiam no instante em que se teleportam para o lado de alguém: o servidor procura os alvos um momento depois, onde ele enxerga os personagens naquela hora. Ela não impede o teleporte em si; para isso é preciso a checagem de movimento descrita em O que um exploiter consegue e não consegue fazer.

Adicione uma animação de golpe (opcional)

O SwordClient já toca uma animação assim que você dá um ID a ele. Você faz a animação uma vez, no Animation Editor do Studio:

  1. Insira um rig para animar. Na aba Avatar ou Home, clique em Character para abrir o Rig Generator e escolha um rig que combine com os avatares do seu jogo, por exemplo R15 e depois Block Avatar.
  2. Na aba Avatar, clique em Clip Editor para abrir o Animation Editor, selecione o rig e monte um golpe curto com o braço direito.
  3. Defina a prioridade como Action: clique no botão … nos controles de reprodução do editor, passe o mouse sobre Set Animation Priority e escolha Action. Action fica acima de Movement, Idle e Core, então o golpe toca por cima das animações de andar e de ficar parado em vez de perder para elas.
  4. No mesmo menu …, escolha Publish to Roblox. Se o seu jogo pertence a um grupo, selecione esse grupo no campo Creator antes de enviar.
  5. Copie o asset ID da animação na Toolbox, e no SwordClient defina o SWING_ANIMATION_ID como "rbxassetid://" seguido desse número.

O SwordClient carrega o golpe pelo Animator do personagem, não pelo antigo Humanoid:LoadAnimation, que a Roblox marca como obsoleto. A referência do Animator da Roblox diz que as animações que o dispositivo de um jogador inicia no próprio personagem daquele jogador replicam para o servidor e para todos os outros jogadores, então o LocalScript pode tocar o golpe e todo mundo vê. Ela também diz que o Animator precisa ser criado no servidor, então nunca crie um em um LocalScript. Os personagens dos jogadores normalmente têm um dentro do Humanoid, que é onde o exemplo de animação da própria Roblox o procura.

A animação é só para mostrar. Os acertos não dependem dela, então uma animação lenta, ausente ou editada nunca muda quem é atingido.

Para tocar uma animação ao apertar uma tecla, em loop ou em um NPC, veja o guia de script de animação.

O que os tutoriais antigos de espada erram

Se você está comparando este guia com um vídeo ou um post de fórum, estas são as diferenças que importam, com o motivo de cada padrão ser um problema.

Padrões comuns em tutoriais de espada, e o que este guia faz no lugar
O tutorialO problemaEste guia
Aplica o dano no evento Touched da lâminaO dispositivo do atacante pode disparar o Touched da própria espada de qualquer lugar (página de network ownership da Roblox), e o Touched dispara várias vezes seguidas em um único contato (página de debounce da Roblox).O servidor acha os alvos com a própria caixa, uma vez por Humanoid por golpe.
Baixa a Health em um LocalScriptUma mudança que um LocalScript faz em outro personagem fica naquele único dispositivo.Todo o dano acontece no SwordService.
Usa wait(0.5) para o cooldownA Roblox marca o wait() global como obsoleto, substituído pelo task.wait(), e um cooldown que só existe no cliente não segura ninguém.Compara tempos de os.clock() no servidor. Nada espera.
Toca o golpe com Humanoid:LoadAnimationObsoleto, substituído pelo Animator:LoadAnimation.Carrega o golpe pelo Animator.
Acha os alvos com Region3 e FindPartsInRegion3Obsoleto. A Roblox manda usar GetPartBoundsInBox com OverlapParams em trabalhos novos.Usa GetPartBoundsInBox.
Põe dentro da Tool um Script de servidor que escuta o ActivatedA espada de cada jogador roda a própria cópia do código de servidor, e esses scripts costumam aplicar o dano no Touched (a primeira linha). Com as configurações padrão, um Script só roda dentro do Workspace ou do ServerScriptService, então um Script em uma Tool não começa até a espada ser equipada pela primeira vez. A página de tools da Roblox descreve a maioria das tools como um LocalScript para a entrada, um Script de servidor para o efeito e um RemoteEvent entre eles.Um SwordService no ServerScriptService cuida de todas as espadas do jogo.

O que um exploiter consegue e não consegue fazer

Parta do princípio de que um trapaceiro controla tudo no próprio dispositivo. Ele consegue ler e mudar os seus LocalScripts, e o guia de segurança da Roblox diz que ele pode disparar RemoteEvents em qualquer frequência e com argumentos arbitrários. Veja o que isso significa para esta espada.

O que um trapaceiro pode tentar, e o que o SwordService faz a respeito
O trapaceiro tentaResultadoPor quê
Disparar o SwordSwing tão rápido quanto o código dele consegue, ou usar um auto-clickerNo máximo um golpe a cada 0,5 segundo valeO cooldown do servidor é de 0,6 segundo menos a folga de rede de 0,1 segundo. Essa folga é o máximo que um trapaceiro ganha.
Enviar um alvo, um número de dano ou uma posição com o remoteIgnoradoO onSwing lê só o jogador, que o próprio Roblox preenche. Qualquer outra coisa enviada com o remote nunca é lida.
Editar o SwordClient, por exemplo para tirar o cooldown deleNenhum efeito no servidorO SwordService guarda as próprias configurações no ServerScriptService, que nunca é enviado aos jogadores.
Golpear morto, ou sem a espada na mãoIgnoradoO SwordService confere se o Humanoid dele está vivo e se uma Tool chamada Sword está dentro do personagem dele, que é para onde o Roblox leva uma tool quando ela é equipada.
Atingir alguém do outro lado do mapaNada aconteceA caixa é montada em volta do personagem do atacante, onde o servidor o enxerga, e alcança só 6 studs à frente.
Teleportar para o lado de um jogador e golpearPossívelCada dispositivo controla o movimento do próprio personagem, e a Roblox lista teleportar para qualquer posição entre as coisas que um cliente pode fazer com o próprio personagem. Uma checagem de movimento no servidor pode sinalizar isso.
Golpear através de uma parede finaPossível dentro da caixa de 6 studsA consulta de caixa do Passo 2 não procura paredes. A Versão 2 adiciona uma checagem de parede.
Tocar qualquer animação, ou nenhumaNenhum efeito nos acertosOs acertos nunca dependem da animação. A Roblox avisa que trapaceiros podem tocar animações arbitrárias no próprio personagem.

Duas linhas dizem "Possível", e isso é honesto. Esta espada impede um trapaceiro de escolher quem ele atinge, com que força e com que frequência. Ela não consegue impedi-lo de mover o próprio personagem. A documentação de segurança da Roblox diz que os clientes controlam o movimento e a física do próprio personagem, e que as checagens de movimento precisam ser ajustadas a cada jogo. Em um jogo competitivo, uma checagem de movimento no servidor é a próxima camada (o guia de corrida monta uma que avisa sobre speed hacks grosseiros e teleportes longos), ou a server authority da Roblox, que a documentação descrevia como um beta quando conferimos em 13 de outubro de 2026.

Passo 4: Teste

  1. Adicione algo para atingir. Na aba Avatar ou Home, clique em Character para abrir o Rig Generator, escolha um rig (por exemplo R15, depois Block Avatar) e ele é inserido no Workspace. Leve o rig a alguns studs da sua SpawnLocation.
  2. Aperte Play, equipe a Sword pela barra de itens, ande até o rig e clique. Uma barra de vida aparece sobre ele depois do primeiro acerto, porque por padrão um Humanoid só mostra a barra quando a Health está abaixo do MaxHealth. Um Humanoid começa com 100 de vida, então o quinto acerto o derruba.
  3. Clique o mais rápido que conseguir. Só um golpe a cada 0,6 segundo faz alguma coisa.
  4. Afaste-se cerca de 8 studs do rig, ou vire as costas para ele, e golpeie. Nada acontece, porque nenhuma part dele está dentro da caixa.
  5. Teste contra um jogador de verdade. Escolha Server & Clients no menu de modo de teste, defina 2 clientes e aperte Play. Atinja o outro jogador nos primeiros 10 segundos depois de ele nascer: nada acontece, por causa do ForceField do spawn. Depois disso, cada acerto tira 20. Por padrão, os personagens dos jogadores também recuperam 1% do MaxHealth por segundo, então a vida deles volta a subir aos poucos entre as lutas.
  6. Se o seu jogo usa Teams, ponha os dois jogadores de teste no mesmo time. Com FRIENDLY_FIRE false, os golpes de um não fazem nada ao outro.

Mantenha a janela Output aberta (menu Window, depois Output) o tempo todo. Estes scripts não imprimem nada quando funcionam, então qualquer erro vermelho do SwordService ou do SwordClient é um problema de verdade. Veja os Erros comuns.

Indo além: um sistema de combate

Combos

Guarde um contador de golpes por jogador no servidor, ao lado do lastSwing. Se o golpe anterior foi recente, some 1; senão, recomece em 1. Depois escolha o dano a partir da contagem, por exemplo mais dano a cada terceiro acerto, e limpe o contador no PlayerRemoving do mesmo jeito. O cliente pode manter a própria contagem para escolher qual animação tocar, porque a animação nunca decide um acerto. A caixa e as checagens ficam exatamente iguais.

Knockback

Depois do TakeDamage, o SwordService pode empurrar o alvo para longe com ApplyImpulse na RootPart do alvo, na direção do rootPart.CFrame.LookVector do atacante. A referência da Roblox diz que o empurrão depende da massa do alvo, e que um Script de servidor pode chamá-lo em uma part que pertence ao servidor ou em uma part que pertence automaticamente a um cliente. O dispositivo de cada jogador simula o próprio personagem, então teste o knockback em jogadores com Server & Clients, não só em um rig.

Crédito de kill para um leaderboard

Logo antes de target:TakeDamage(DAMAGE), registre quem atingiu por último com target:SetAttribute("LastHitBy", player.UserId). Em um Script de servidor, conecte o evento Died do Humanoid de cada personagem, leia esse atributo, ache o atacante com Players:GetPlayerByUserId e some 1 a um IntValue Kills no leaderstats dele. Crie esse valor ao lado de Coins e Wins como no Passo 1 do guia de leaderboard, e mude no servidor como no Passo 2.

Bloqueio

Adicione um segundo RemoteEvent que o cliente dispara quando o botão de bloqueio é apertado e solto, e faça o servidor definir um atributo Blocking no personagem daquele jogador, com o próprio limite de taxa. No SwordService, reduza ou pule o dano quando o personagem do alvo tem Blocking definido. Um trapaceiro ainda escolhe quando bloqueia, então deixe o bloqueio curto ou dê a ele um cooldown.

Vender a espada ou entregá-la a cada rodada

O StarterPack dá a espada a todo jogador a cada spawn. Para vendê-la, coloque na pasta ShopItems do guia de GUI de loja. O catálogo daquele guia já vende uma Tool chamada ClassicSword, então ou dê a esta Tool o nome ClassicSword e ajuste o SWORD_NAME, ou mude a entrada do catálogo. Para entregá-la só durante uma rodada, use o script GiveRoundTool do guia de sistema de rodadas: guarde a Sword no ServerStorage em vez do StarterPack, e troque "RoundTool" naquele script por "Sword".

Inimigos para enfrentar, e uma arma de longo alcance

Para um NPC que persegue os jogadores, siga o guia de pathfinding de NPC. A espada dá dano nele como em qualquer outro Humanoid. Para uma arma que acerta de longe com as mesmas regras de servidor, veja o guia de arma de fogo (em inglês).

Erros comuns e como resolver

Abra a janela Output (menu Window, depois Output) antes de apertar Play. A maioria dos problemas de espada ou imprime um erro ali ou vem de um nome que não bate.

Infinite yield possible on 'ReplicatedStorage:WaitForChild("SwordSwing")'

O SwordClient está esperando o remote que o SwordService cria, então o SwordService não está rodando. Confira que ele é um Script, não um LocalScript, direto dentro do ServerScriptService, que não está desativado, e que o Output não mostra nenhum erro dele.

Eu golpeio, mas nada leva dano

Confira nesta ordem: o SwordClient é um LocalScript, não um Script, direto dentro da Tool Sword; a Tool se chama exatamente Sword, ou o que estiver em SWORD_NAME; o alvo está a até 6 studs à sua frente; o alvo nasceu há mais de 10 segundos, então o ForceField do spawn já sumiu; e, se você usa Teams, que vocês não estão no mesmo time com FRIENDLY_FIRE false.

A espada atinge jogadores, mas nunca o meu NPC

Consultas espaciais como GetPartBoundsInBox nunca devolvem uma part com o CanQuery desligado (o CanQuery só tem efeito quando o CanCollide também está desligado). Ligue o CanQuery de novo nas parts do corpo do NPC, e confira que o Humanoid dele é filho direto do model do NPC.

O meu personagem fica preso quando equipo a espada

Alguma part da espada está ancorada. Selecione todas as parts dentro da Tool e desmarque Anchored.

Alguns golpes acertam e outros erram à mesma distância

Na versão com preparação, um alvo que sai da caixa durante o WINDUP_SECONDS não é atingido, e a checagem de parede pula quem está atrás de uma parede ou de outro jogador. Diminua a preparação, ou aumente o HIT_WIDTH, se os erros parecerem injustos nos testes.

O personagem segura a espada pela lâmina

Há mais de uma part chamada Handle, então o Roblox escolheu a errada. Deixe exatamente um Handle, o cabo, e renomeie os outros. Depois ajuste as propriedades de empunhadura da Tool se o ângulo ainda estiver errado.

A lâmina fica para trás ou cai quando equipo a espada

A lâmina não está soldada ao Handle. Adicione um WeldConstraint com o Part0 definido como Handle e o Part1 como a lâmina.

O dano aparece na minha tela, mas a vida do outro jogador não muda

O dano está sendo aplicado em um LocalScript, que muda só a sua cópia do jogo. Aplique dano só no SwordService, como no Passo 2.

Crie com o RoCode

Se você prefere não ligar tudo isso à mão, o RoCode pode construir no jogo que você tem aberto. Ele é um agente de IA de programação independente, não feito pela Roblox: você descreve a funcionalidade no chat dele na web, e o plugin dele para o Roblox Studio cria a Tool, as parts e os scripts no seu Explorer, então você não fica copiando código de uma janela de chat.

Você digita

Faça uma espada: uma Tool chamada Sword no StarterPack com um Handle e uma lâmina soldada a ele, um LocalScript que dispara um RemoteEvent no Activated, e um Script de servidor que confere um cooldown de 0,6 segundo e dá 20 de dano aos Humanoids em uma caixa à frente do jogador.

O RoCode faz
  • Cria a Tool e as parts dela com Create Instance e define as propriedades com Set Property
  • Escreve o SwordService e o SwordClient com Create Script, e pode procurar antes scripts de combate que já existam com Search Scripts
  • É instruído a checar a compilação de cada script que escreve com Check Script, que compila o código no Studio sem rodá-lo (ele não verifica os tipos)
  • Cria um ponto de desfazer antes e depois de cada lote de mudanças, então Ctrl+Z volta um lote de cada vez

O RoCode não consegue fazer a animação do golpe nem enviar uma: faça no Animation Editor e cole o ID dela. Com o plugin 3.9 ou mais recente, o RoCode pode rodar um teste curto e ler os erros, e com o plugin 3.9.11 ou mais recente ele pode controlar um personagem de teste, mas ele não clica na vista 3D para golpear, então é você quem testa os golpes. Criar um jogo Roblox inteiro com o RoCode, sistema por sistema mostra onde uma arma se encaixa. Como o RoCode se conecta ao Studio.

Perguntas frequentes

Por que a minha espada atinge o mesmo jogador várias vezes em um golpe?

Porque ela aplica o dano pelo Touched. A página de debounce da própria Roblox avisa que o Touched dispara várias vezes seguidas em um único contato, e toda part do alvo pode tocar na lâmina. Este guia acha os alvos com uma consulta de caixa por golpe e guarda uma lista, então cada Humanoid perde vida uma vez por golpe.

O dano da espada deve ficar em um LocalScript ou em um Script?

Em um Script no servidor. O dano aplicado em um LocalScript muda só a cópia do jogo daquele jogador, e tudo o que está no dispositivo do jogador pode ser mudado por um trapaceiro. O LocalScript deve só escutar o clique, tocar a animação e disparar o RemoteEvent.

Como adicionar uma animação de golpe à minha espada?

Faça no Animation Editor, defina a prioridade como Action, publique no Roblox e coloque o asset ID dela no SWING_ANIMATION_ID como rbxassetid:// seguido do número. O SwordClient a toca com o Animator do personagem. As animações que o dispositivo de um jogador inicia no próprio personagem daquele jogador são mostradas a todos.

Por que a animação da minha espada não toca?

Confira três coisas. A prioridade: Action fica acima de Movement, Idle e Core, então um golpe Action toca por cima de andar e de ficar parado, enquanto uma prioridade mais baixa pode perder para elas. O dono: se o jogo pertence a um grupo, publique a animação com esse grupo selecionado como Creator. O ID: o SWING_ANIMATION_ID precisa ser o texto rbxassetid:// completo com o número da sua animação, não uma string vazia.

Qual é a melhor hitbox para uma espada no Roblox?

Para a maioria dos jogos, uma consulta de caixa no servidor uma vez por golpe, como neste guia: uma chamada a GetPartBoundsInBox, nada para um cliente falsificar e três números para ajustar. Use GetPartsInPart com uma part com forma, ou raycasts ao longo da lâmina, só quando o alcance de uma arma está longe de ser uma caixa. Os quatro métodos comparados.

Como impedir a minha espada de atingir pessoas através de paredes?

Antes de aplicar o dano, lance um raio da root part do atacante até a root part do alvo, pulando o personagem do atacante, e só conte o acerto se a primeira coisa que o raio encontra pertence ao alvo. A Versão 2 do SwordService faz isso para todo alvo.

Por que o golpe acerta antes de a animação chegar ao alvo?

O servidor confere a hitbox no instante em que o clique chega. Espere antes uma preparação curta, por exemplo 0,15 segundo com task.delay, depois confira se o atacante ainda está vivo e segurando a espada e monte a caixa, como faz a Versão 2.

Os exploiters ainda conseguem trapacear com esta espada?

Eles não conseguem escolher quem é atingido, quanto dano um acerto dá nem com que frequência golpeiam, porque o servidor decide as três coisas; o máximo que ganham é a folga de rede de 0,1 segundo no cooldown. Eles ainda conseguem mover o próprio personagem, por exemplo para bem ao lado de alguém, porque cada dispositivo controla o movimento do próprio personagem. Uma checagem de movimento no servidor é a próxima camada.

Como fazer um sistema de combate com combos?

Guarde um contador de golpes por jogador no servidor, zere depois de uma pausa curta, e escolha o dano e a animação a partir da contagem. A checagem de acerto fica igual. Indo além também cobre knockback, crédito de kill e bloqueio.

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.