Tutorial · Sistemas de juego

Cómo hacer una espada en Roblox Studio

Una espada en Roblox es una Tool con tres tareas repartidas en dos scripts: el dispositivo del jugador detecta el clic y reproduce el ataque, y el servidor decide a quién se golpeó y cuánta vida pierde. Esta guía construye los dos, con un tiempo de espera y una hitbox que los jugadores no pueden falsificar, y muestra dónde encaja una animación.

Actualizado el 12 de noviembre de 202627 min de lecturaEscrito por

La respuesta corta

Pon en StarterPack una Tool llamada Sword con una parte llamada Handle. Un LocalScript en la Tool escucha Tool.Activated, reproduce la animación del ataque y dispara un RemoteEvent sin argumentos. Un Script en ServerScriptService comprueba el tiempo de espera y que el jugador está vivo y con la espada en la mano, encuentra los Humanoids dentro de una caja delante de él con workspace:GetPartBoundsInBox y llama a Humanoid:TakeDamage una vez por objetivo.

  • No apliques el daño desde el evento Touched de la hoja: el dispositivo del jugador controla su propio personaje y puede disparar Touched desde cualquier lugar, y ese es justo el ejemplo de la espada que da la página de propiedad de red de Roblox.
  • El cliente no envía ni objetivo ni daño. El tiempo de espera, la hitbox y la cantidad de daño son del servidor.
  • TakeDamage no hace nada mientras el objetivo tiene un ForceField, como en los 10 segundos después de aparecer en un SpawnLocation.
  • ¿Golpes a través de paredes, o golpes que llegan antes de que el ataque parezca conectar? Usa la versión con preparación y comprobación de paredes del script del servidor.
En esta página
  1. Cómo encaja todo
  2. 1. Construir la Tool
  3. 2. Script del servidor
  4. 3. LocalScript
  5. La hitbox
  6. Métodos de hitbox
  7. Preparación y paredes
  8. Animación de ataque
  9. Tutoriales antiguos
  10. Límites de los exploits
  11. 4. Probar
  12. Ampliarlo
  13. Errores comunes
  14. Con RoCode
  15. Preguntas frecuentes
  16. Fuentes y lecturas

Cómo encajan las piezas de una espada que funciona

IlustraciónLos ataques separados por al menos 0.6 segundos quitan 20 de vida cada uno, un clic dentro del tiempo de espera no hace nada, y el quinto golpe derrota al rig.

Una espada que funciona en un juego en vivo está repartida entre el dispositivo del jugador y el servidor. La página de tools de Roblox dice que la entrada de una tool va en LocalScripts, porque solo el dispositivo del jugador sabe cuándo ocurre la entrada, y que la mayoría de las tools necesitan un LocalScript, un Script del servidor y un RemoteEvent entre los dos. Esta guía usa exactamente ese reparto. Un ataque va así:

  1. El jugador hace clic, toca la pantalla o pulsa el gatillo del mando con la Sword equipada. Tool.Activated se dispara en el LocalScript.
  2. El LocalScript reproduce la animación del ataque, si hay una, y dispara el RemoteEvent SwordSwing. No envía nada más.
  3. El Script del servidor comprueba el tiempo de espera, que el jugador está vivo y que tiene la Sword en la mano.
  4. El servidor construye su propia hitbox delante del personaje del jugador y encuentra todos los Humanoids que hay dentro.
  5. Cada uno de esos Humanoids pierde vida una vez, mediante TakeDamage.
Las piezas de la espada
PiezaDónde vaQué hace
Tool SwordStarterPackLo que sujeta el jugador. Roblox copia todo lo que hay en StarterPack al Backpack del jugador cada vez que aparece su personaje.
Part HandleDentro de la ToolLa parte que agarra el personaje. La hoja está soldada a ella.
LocalScript SwordClientDentro de la ToolDetecta el clic, reproduce la animación del ataque y dispara el remote.
RemoteEvent SwordSwingReplicatedStorage (lo crea SwordService)Lleva el "ataqué" del dispositivo del jugador al servidor, sin argumentos.
Script SwordServiceServerScriptServiceComprueba cada ataque, encuentra a quién hay delante del jugador y aplica el daño. Es el único lugar donde puede ocurrir un golpe.
El Explorer cuando la espada está terminada. SwordService añade un RemoteEvent llamado SwordSwing a ReplicatedStorage cuando el juego se ejecuta.
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

Paso 1: construye la Tool de la espada

  1. En el Explorer, pasa el ratón sobre Workspace, haz clic en el botón + e inserta una Tool. Cámbiale el nombre a Sword. El script del servidor busca este nombre exacto. La espada se construye en Workspace, como sugiere la página de tools de Roblox, porque ahí puedes ver sus partes, moverlas y cambiarles el tamaño. El último paso la mueve a StarterPack.
  2. Inserta una Part en la Tool y llámala Handle. Es la empuñadura, por donde el personaje sujeta la espada. Debe ser hija directa de la Tool, y debe ser la única parte con ese nombre: con dos Handles, Roblox elige una al azar, y el personaje puede acabar sujetando la espada por la hoja.
  3. Inserta una segunda Part en la Tool, llámala Blade, y dale forma y posición para que sobresalga por arriba del Handle.
  4. Inserta un WeldConstraint en Blade. En la ventana Properties, pon su Part0 en Handle y su Part1 en Blade, para que la espada siga en una pieza mientras el jugador la lleva.
  5. Selecciona las dos partes y asegúrate de que Anchored está desactivado. Una parte anclada dentro de una tool deja al personaje clavado en el sitio cuando la equipa. Desactiva también CanCollide en las dos, para que la hoja no choque con jugadores y paredes al atacar.
  6. Selecciona la Tool y desmarca CanBeDropped. Cuando está marcado, pulsar Retroceso suelta la espada en Workspace.
  7. Arrastra la Sword terminada desde Workspace a StarterPack. Una Tool que se queda en Workspace es un objeto que recoge un solo jugador, no una espada que empieza en el Backpack de todos.

Una espada hecha con un solo MeshPart también funciona: llama Handle a ese MeshPart y sáltate el weld. Si el personaje sujeta la espada en un ángulo raro cuando la pruebas, selecciona la Tool y ajusta sus propiedades de agarre (GripPos, GripForward, GripRight y GripUp) en la ventana Properties.

Paso 2: añade el script del servidor

Pasa el ratón sobre ServerScriptService, inserta un Script llamado SwordService y pega el código de abajo. Es el único lugar donde puede ocurrir un golpe de espada. Los ajustes del principio son las líneas pensadas para que las cambies.

Script en ServerScriptService llamado SwordService
-- Script en ServerScriptService llamado SwordService.
-- El único lugar donde puede ocurrir un golpe de espada: comprueba el ataque, encuentra objetivos delante
-- del atacante con su propia hitbox y aplica el daño.

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

-- Ajustes
local SWORD_NAME = "Sword" -- el nombre de la Tool en StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- pon el mismo valor en SwordClient
local HIT_RANGE = 6 -- studs delante del atacante
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false: los jugadores del mismo equipo no pueden hacerse daño
-- Los ataques enviados exactamente cada COOLDOWN_SECONDS pueden llegar un poco más juntos después de un
-- retraso de red, así que el servidor permite este margen en vez de descartar un ataque real
local NETWORK_SLACK = 0.1

-- El remote que dispara el LocalScript de la espada. No lleva argumentos: el servidor
-- decide a quién se golpea, así que no hay nada que un cliente pueda 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
	-- Los jugadores neutrales (sin equipo) siempre pueden golpearse entre sí
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

local function onSwing(player: Player)
	-- 1. Un ataque por tiempo de espera, por muchas veces que se dispare el remote
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end

	-- 2. El atacante debe estar vivo y con la espada en la mano
	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. La hitbox propia del servidor: una caja delante de la parte raíz del 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. Daña a cada Humanoid de la caja una vez, aunque varias de sus partes estén 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) -- no hace nada mientras el objetivo tiene un ForceField
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(onSwing)

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

SwordService crea el RemoteEvent SwordSwing por su cuenta cuando empieza el juego, así que no hay nada que insertar a mano en ReplicatedStorage. Si ya hiciste un RemoteEvent con ese nombre, bórralo: el LocalScript podría encontrar el tuyo, al que nada escucha en el servidor.

Los ajustes del principio de SwordService
AjusteValor aquíQué cambia
SWORD_NAME"Sword"El nombre de la Tool que el servidor espera en la mano del jugador. Cámbialo si tu Tool tiene otro nombre.
DAMAGE20La vida que quita cada golpe. Un Humanoid empieza con 100 de vida, así que cinco golpes derrotan al rig de prueba. Los personajes de los jugadores recuperan por defecto el 1% de su MaxHealth cada segundo, así que un jugador golpeado a la máxima velocidad de ataque sobrevive al quinto golpe y necesita un sexto.
COOLDOWN_SECONDS0.6El tiempo entre ataques. Pon el mismo valor en SwordClient.
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6La hitbox en studs: cuánto alcanza delante del jugador, qué ancho tiene y qué alto.
FRIENDLY_FIREfalseCuando es false, los jugadores del mismo equipo no pueden hacerse daño. Los jugadores sin equipo siempre pueden golpearse entre sí, y a los NPCs siempre se les puede golpear.
NETWORK_SLACK0.1Cuánto antes del tiempo de espera acepta todavía un ataque el servidor. Dos clics separados por 0.6 segundos pueden llegar un poco más juntos después de un retraso de red, y sin este margen el servidor descartaría un ataque real que el jugador ya vio.

Paso 3: añade el LocalScript en la Tool

Inserta un LocalScript en la Tool Sword, llámalo SwordClient y pega esto:

LocalScript en la Tool Sword en StarterPack llamado SwordClient
-- LocalScript dentro de la Tool Sword, llamado SwordClient.
-- Tool.Activated se dispara en el dispositivo del jugador, así que este script escucha el clic,
-- el toque o el gatillo, reproduce la animación del ataque y le pide al servidor que ataque.

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 -- el mismo valor que en SwordService
local SWING_ANIMATION_ID = "" -- opcional: "rbxassetid://" seguido del id de tu animación

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

-- Carga la animación una vez por personaje. Las animaciones que empiezas en tu propio personaje
-- desde tu dispositivo se muestran a todos los jugadores.
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 -- el servidor también lo exige; comprobarlo aquí evita peticiones desperdiciadas
	end
	lastSwing = now
	if swingTrack then
		swingTrack:Play()
	end
	swingEvent:FireServer()
end)

Deja SWING_ANIMATION_ID vacío por ahora. La espada funciona sin animación, porque el servidor decide el golpe de todos modos. Añade una animación de ataque muestra cómo rellenarlo.

Activated se dispara con un clic del ratón, un toque en un teléfono y el gatillo de un mando, así que el mismo script funciona en todos los dispositivos. Roblox copia la Tool, y el LocalScript que lleva dentro, al Backpack de cada jugador cuando aparece su personaje, así que cada jugador ejecuta su propia copia.

El LocalScript lleva su propio tiempo de espera solo para no enviar peticiones que el servidor ignoraría de todos modos. No es una comprobación de seguridad: un tramposo puede borrarlo, editarlo o disparar SwordSwing desde su propio código. La guía de RemoteEvents explica por qué todo remote hay que comprobarlo en el servidor, y Script vs LocalScript vs ModuleScript (en inglés) muestra qué puede y qué no puede cambiar un LocalScript.

Cómo decide el servidor a quién se golpea

Cuando llega SwordSwing, SwordService no le pregunta nada al cliente. Construye una caja delante del personaje del atacante, donde lo ve el servidor, y le pregunta al motor qué partes hay dentro con workspace:GetPartBoundsInBox. Ese método reemplaza al antiguo FindPartsInRegion3, que Roblox marca como obsoleto.

La caja está centrada 3 studs delante de la parte raíz del atacante. Ese es el desplazamiento CFrame.new(0, 0, -HIT_RANGE / 2): un CFrame mira a lo largo de su eje Z negativo, su LookVector. Así que la caja va desde el centro del personaje hasta 6 studs por delante, y mide 5 studs de ancho y 6 de alto. La consulta compara la caja delimitadora de cada parte, una aproximación rápida en forma de caja de su volumen, así que las partes redondas y los meshes cuentan como un poco más grandes de lo que se ven. Para una espada, ese pequeño margen ayuda.

Qué hace SwordService con las partes de la caja
PasoCódigoPor qué
Saltarse al atacanteOverlapParams con Exclude y el personaje del atacanteLos brazos, las piernas y la espada del propio atacante también están dentro de la caja.
Encontrar el personajepart:FindFirstAncestorOfClass("Model")Una parte de la caja puede ser una extremidad, un sombrero o una tool en la mano. FindFirstAncestorOfClass compara el nombre exacto de la clase, así que pasa de largo un sombrero (clase Accessory) y una tool en la mano (clase Tool, aunque una Tool es un tipo de Model) y se detiene en el modelo del personaje.
Encontrar el Humanoidmodel:FindFirstChildOfClass("Humanoid")Se puede golpear todo lo que tenga un Humanoid: jugadores, NPCs y muñecos de prueba. Las paredes y los suelos se saltan.
Una vez por Humanoidla tabla alreadyHitNormalmente hay varias partes de un mismo personaje dentro de la caja. Sin la tabla, cada una aplicaría el daño otra vez.
Solo objetivos vivostarget.Health > 0A un personaje que ya está derrotado no se le golpea otra vez.
EquiposisTeammateCon FRIENDLY_FIRE en false, se saltan los jugadores del mismo equipo. Un jugador cuya propiedad Neutral es true no tiene equipo.
Dañotarget:TakeDamage(DAMAGE)Baja Health a menos que un ForceField proteja al objetivo.

La tabla alreadyHit se crea de nuevo en cada ataque, así que al mismo jugador se le puede golpear otra vez en el siguiente ataque cuando haya pasado el tiempo de espera. Esa es la regla de "una vez por objetivo por ataque" con la que tienen problemas las espadas basadas en Touched.

El script usa TakeDamage en vez de asignar Health. La referencia de Roblox dice que TakeDamage no toca a un Humanoid mientras lo protege un ForceField, y que asignar Health directamente ignora los ForceFields. Un jugador que aparece en un SpawnLocation recibe un ForceField durante 10 segundos por defecto (el Duration del SpawnLocation), así que a los recién llegados no se les puede golpear en el momento en que aparecen.

Cuatro formas de hacer la hitbox de una espada, comparadas

Los tutoriales de espadas discrepan sobre todo en una cosa: cómo saber qué golpeó la hoja. Hay cuatro respuestas comunes. Se diferencian en lo fielmente que siguen la hoja, en cuánto trabajo le cuestan al servidor y en si un tramposo puede falsificar el resultado.

Métodos de hitbox para espadas. "Quién decide" es el lado cuya respuesta cuenta
MétodoCómo funcionaQuién decidePrecisiónIdeal para
Touched en la hojaDaño cada vez que la parte de la hoja toca un personajeEl dispositivo del atacante, que es dueño de su propio personaje y de su espadaSigue la hoja, pero se dispara varias veces por contactoNada en un juego con otros jugadores: el dispositivo del atacante puede dispararlo desde cualquier lugar
Una caja delante del jugador (esta guía)Una consulta GetPartBoundsInBox en el servidor por ataqueEl servidorUna caja fija, no la trayectoria de la hoja. Los meshes cuentan por sus cajas delimitadoras, así que es un poco generosaLa mayoría de los juegos: simple, barata y sin nada que falsificar
GetPartsInPart con una parte hitboxUna consulta en el servidor con una parte con la forma del barrido de la hoja, durante el ataqueEl servidorFormas exactas: la documentación de Roblox dice que hace una comprobación geométrica completa, y sugiere las consultas de caja o de esfera cuando basta con menos precisión, porque son más baratasArmas grandes con formas raras, como el arco de una guadaña
Raycasts a lo largo de la hojaEn cada frame del ataque, lanza rayos cortos desde puntos de la hoja hasta donde estaban en el frame anteriorEl lado que los lance. En el servidor necesita la idea que tiene el servidor de dónde está la hojaSigue la animación de cercaJuegos donde importa la trayectoria exacta del ataque. Los módulos de hitbox de la comunidad funcionan así

La caja es la primera opción correcta. Es una consulta por ataque, nunca depende de una animación que un tramposo podría cambiar, y es fácil de ajustar con tres números. Cambia a una parte con forma o a rayos en la hoja cuando los jugadores se quejen de que los golpes se sienten mal en un arma cuyo alcance se parece poco a una caja, y deja la regla igual: el servidor hace la consulta y aplica el daño.

Ajustes de espada: de la daga al espadón

El mismo SwordService hace armas muy distintas con cinco ajustes. La tabla es un punto de partida, calculado contra un muñeco del Rig Generator con 100 de Health. El "tiempo hasta derrotarlo" cuenta desde el primer golpe, con cada ataque acertando en cuanto lo permite el tiempo de espera.

Ajustes de SwordService para armas cuerpo a cuerpo comunes, con los golpes y el tiempo para derrotar a un muñeco con 100 de Health. Calculado, no medido
ArmaDAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTHGolpes (tiempo)Daño por segundo
Daga120.35449 (2.8 s)unos 34
Espada (esta guía)200.6655 (2.4 s)unos 33
Espadón351.1773 (2.2 s)unos 32
Lanza180.8936 (4 s)unos 23
  • Los jugadores se curan, los muñecos no. Los personajes de los jugadores recuperan por defecto el 1% de su MaxHealth cada segundo. Con exactamente 100 de daño en 5 golpes, un jugador golpeado a toda velocidad sobrevive al quinto golpe y necesita un sexto. Deja un margen, por ejemplo 21 de daño en vez de 20, si importa un número fijo de golpes.
  • Escala NETWORK_SLACK con el tiempo de espera. Los 0.1 segundos de la guía son una sexta parte de 0.6. Si se deja en 0.1 con una daga de 0.35 segundos, un tramposo podría atacar cada 0.25 segundos, un 40% más rápido. Usa más o menos una sexta parte de COOLDOWN_SECONDS: 0.06 para la daga.
  • Mantén SwordClient a la par. Pon ahí el mismo COOLDOWN_SECONDS, o el cliente envía ataques que el servidor ignora.

Versión 2: con preparación y sin golpes a través de paredes

Cuando la espada básica funciona aparecen dos quejas. El golpe llega en el instante en que el jugador hace clic, antes de que la animación del ataque alcance al objetivo, y un ataque puede alcanzar a alguien al otro lado de una pared fina, porque la caja ignora las paredes. Esta versión de SwordService arregla las dos. Reemplaza el script del paso 2: mismo nombre, mismo remote, mismos ajustes, así que SwordClient no necesita ningún cambio.

Script en ServerScriptService llamado SwordService
-- Script en ServerScriptService llamado SwordService (la versión con preparación y comprobación de paredes).
-- Reemplaza el script del paso 2: mismos ajustes y remote, más dos reglas. El golpe llega
-- WINDUP_SECONDS después del clic, cuando el ataque alcanza al objetivo, y no se golpea a nadie
-- a través de una pared.

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

-- Ajustes
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- pon el mismo valor en SwordClient
local WINDUP_SECONDS = 0.15 -- tiempo desde el clic hasta el golpe; ajústalo a tu animación de ataque
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

-- Devuelve el personaje y la parte raíz del atacante mientras esté vivo y con la espada en la mano
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 cuando no hay nada más que el objetivo entre el atacante y el objetivo
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)
	-- Se comprueba otra vez después de la preparación: el atacante pudo haber muerto o guardado la 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)

Borra primero el SwordService del paso 2, o cada uno de los dos scripts crea un remote SwordSwing. Pon WINDUP_SECONDS en el momento de tu animación de ataque en que la hoja pasa por delante del personaje; 0.15 va bien para un ataque rápido.

  • La preparación. El tiempo de espera y las comprobaciones de "vivo y con la espada en la mano" se hacen cuando llega el clic, y luego task.delay ejecuta strike WINDUP_SECONDS después. strike comprueba otra vez al atacante, porque pudo haber muerto o guardado la espada mientras tanto, y solo entonces construye la caja. A un objetivo que sale del alcance durante la preparación no se le acierta, que es lo que esperan los jugadores cuando ven el ataque.
  • La comprobación de paredes. Para cada objetivo de la caja, hasClearLine lanza un rayo desde la parte raíz del atacante hasta la parte raíz del objetivo, saltándose el personaje del propio atacante. Si lo primero que encuentra pertenece al objetivo, o no encuentra nada, el golpe cuenta. Una pared, una puerta u otro jugador en medio lo bloquea.
  • Lo que cuesta. Un rayo extra por objetivo por ataque, que es poco al lado de la propia consulta de la caja.

La preparación también hace la espada más justa contra los tramposos que atacan en el momento en que se teletransportan junto a alguien: el servidor busca los objetivos un momento después, donde ve a los personajes en ese instante. No detiene el teletransporte en sí; para eso hace falta la comprobación de movimiento descrita en Qué puede y qué no puede hacer un exploiter.

Añade una animación de ataque (opcional)

SwordClient ya reproduce una animación en cuanto le das un ID. La animación se hace una sola vez, en el Animation Editor de Studio:

  1. Inserta un rig para animar. En la pestaña Avatar o Home, haz clic en Character para abrir el Rig Generator y elige un rig que coincida con los avatares de tu juego, por ejemplo R15 y luego Block Avatar.
  2. En la pestaña Avatar, haz clic en Clip Editor para abrir el Animation Editor, selecciona el rig y crea un movimiento corto de ataque con el brazo derecho.
  3. Pon la prioridad en Action: haz clic en el botón … de los controles de reproducción del editor, pasa el ratón sobre Set Animation Priority y elige Action. Action está por encima de Movement, Idle y Core, así que el ataque se reproduce por encima de las animaciones de caminar y de estar de pie en vez de perder contra ellas.
  4. En el mismo menú …, elige Publish to Roblox. Si tu juego pertenece a un grupo, selecciona ese grupo en el campo Creator antes de enviarla.
  5. Copia el asset ID de la animación desde la Toolbox, y en SwordClient pon SWING_ANIMATION_ID en "rbxassetid://" seguido de ese número.

SwordClient carga el ataque a través del Animator del personaje, no del antiguo Humanoid:LoadAnimation, que Roblox marca como obsoleto. La referencia de Animator de Roblox dice que las animaciones que el dispositivo de un jugador empieza en el propio personaje de ese jugador se replican al servidor y a todos los demás jugadores, así que el LocalScript puede reproducir el ataque y todos lo ven. También dice que el Animator debe crearse en el servidor, así que nunca crees uno en un LocalScript. Los personajes de los jugadores normalmente tienen uno dentro del Humanoid, que es donde lo busca el propio ejemplo de animación de Roblox.

La animación es solo para verse bien. Los golpes no dependen de ella, así que una animación lenta, ausente o editada nunca cambia a quién se golpea.

Para reproducir una animación al pulsar una tecla, en bucle o en un NPC, consulta la guía de scripts de animación.

En qué fallan los tutoriales de espadas antiguos

Si estás comparando esta guía con un video o una publicación de un foro, estas son las diferencias que importan, con la razón por la que cada patrón es un problema.

Patrones comunes en tutoriales de espadas, y lo que hace esta guía en su lugar
El tutorialEl problemaEsta guía
Aplica el daño en el evento Touched de la hojaEl dispositivo del atacante puede disparar Touched en su propia espada desde cualquier lugar (página de propiedad de red de Roblox), y Touched se dispara varias veces seguidas por un solo contacto (página de debounce de Roblox).El servidor encuentra los objetivos con su propia caja, una vez por Humanoid por ataque.
Baja Health en un LocalScriptUn cambio que hace un LocalScript en otro personaje se queda en ese dispositivo.Todo el daño ocurre en SwordService.
Usa wait(0.5) para el tiempo de esperaRoblox marca el wait() global como obsoleto y lo reemplaza task.wait(), y un tiempo de espera que solo existe en el cliente no detiene a nadie.Compara tiempos de os.clock() en el servidor. Nada espera.
Reproduce el ataque con Humanoid:LoadAnimationObsoleto; lo reemplaza Animator:LoadAnimation.Carga el ataque a través del Animator.
Encuentra los objetivos con Region3 y FindPartsInRegion3Obsoleto. Roblox dice que uses GetPartBoundsInBox con OverlapParams en el trabajo nuevo.Usa GetPartBoundsInBox.
Pone dentro de la Tool un Script del servidor que escucha ActivatedLa espada de cada jugador ejecuta su propia copia del código del servidor, y estos scripts suelen aplicar el daño en Touched (la primera fila). Con los ajustes por defecto un Script solo se ejecuta dentro de Workspace o ServerScriptService, así que un Script en una Tool no empieza hasta que la espada se equipa por primera vez. La página de tools de Roblox describe la mayoría de las tools como un LocalScript para la entrada, un Script del servidor para el efecto y un RemoteEvent entre los dos.Un solo SwordService en ServerScriptService maneja todas las espadas del juego.

Qué puede y qué no puede hacer un exploiter

Da por hecho que un tramposo controla todo en su propio dispositivo. Puede leer y cambiar tus LocalScripts, y la guía de seguridad de Roblox dice que puede disparar RemoteEvents con cualquier frecuencia y con argumentos arbitrarios. Esto es lo que significa para esta espada.

Qué puede intentar un tramposo, y qué hace SwordService al respecto
El tramposo intentaResultadoPor qué
Disparar SwordSwing tan rápido como pueda su código, o usar un auto-clickerComo máximo cuenta un ataque cada 0.5 segundosEl tiempo de espera del servidor es de 0.6 segundos menos el margen de red de 0.1 segundos. Ese margen es lo máximo que gana un tramposo.
Enviar un objetivo, un número de daño o una posición con el remoteSe ignoraonSwing lee solo el jugador, que rellena el propio Roblox. Todo lo demás que se envíe con el remote nunca se lee.
Editar SwordClient, por ejemplo para quitarle el tiempo de esperaSin efecto en el servidorSwordService guarda sus propios ajustes en ServerScriptService, que nunca se envía a los jugadores.
Atacar estando muerto, o sin la espada en la manoSe ignoraSwordService comprueba que su Humanoid está vivo y que hay una Tool llamada Sword dentro de su personaje, que es a donde Roblox mueve una tool cuando se equipa.
Golpear a alguien desde el otro lado del mapaNo pasa nadaLa caja se construye alrededor del personaje del atacante donde lo ve el servidor, y alcanza solo 6 studs por delante.
Teletransportarse junto a un jugador y luego atacarPosibleCada dispositivo controla el movimiento de su propio personaje, y Roblox incluye teletransportarse a cualquier posición entre las cosas que un cliente puede hacer con su propio personaje. Una comprobación de movimiento en el servidor puede detectarlo.
Atacar a través de una pared finaPosible dentro de la caja de 6 studsLa consulta de caja del paso 2 no busca paredes. La versión 2 añade una comprobación de paredes.
Reproducir cualquier animación, o ningunaSin efecto en los golpesLos golpes nunca dependen de la animación. Roblox indica que los tramposos pueden reproducir animaciones arbitrarias en su propio personaje.

Dos filas dicen "Posible", y esa es la verdad. Esta espada impide que un tramposo elija a quién golpea, con cuánta fuerza y con qué frecuencia. No puede impedir que mueva su propio personaje. La documentación de seguridad de Roblox dice que los clientes controlan el movimiento y la física de su personaje, y que las comprobaciones de movimiento hay que ajustarlas a cada juego. Para un juego competitivo, la siguiente capa es una comprobación de movimiento en el servidor (la guía de sprint construye una, que avisa de speed hacks burdos y teletransportes largos), o la autoridad del servidor de Roblox, que la documentación describía como una beta cuando lo revisamos el 13 de octubre de 2026.

Paso 4: pruébalo

  1. Añade algo que golpear. En la pestaña Avatar o Home, haz clic en Character para abrir el Rig Generator, elige un rig (por ejemplo R15 y luego Block Avatar) y se inserta en Workspace. Muévelo a unos studs de tu SpawnLocation.
  2. Pulsa Play, equipa la Sword desde la barra de herramientas, acércate al rig y haz clic. Después del primer golpe aparece una barra de vida sobre él, porque por defecto un Humanoid muestra su barra solo cuando su Health está por debajo de su MaxHealth. Un Humanoid empieza con 100 de vida, así que el quinto golpe lo derrota.
  3. Haz clic tan rápido como puedas. Solo un ataque cada 0.6 segundos hace algo.
  4. Aléjate unos 8 studs del rig, o dale la espalda, y ataca. No pasa nada, porque ninguna de sus partes está dentro de la caja.
  5. Prueba contra un jugador real. Elige Server & Clients en el desplegable del modo de prueba, pon 2 clientes y pulsa Play. Golpea al otro jugador antes de que pasen 10 segundos desde que apareció: no pasa nada, por el ForceField de aparición. Después de eso, cada golpe quita 20. Por defecto, los personajes de los jugadores además recuperan el 1% de su MaxHealth cada segundo, así que su vida vuelve a subir poco a poco entre peleas.
  6. Si tu juego usa Teams, pon a los dos jugadores de prueba en el mismo equipo. Con FRIENDLY_FIRE en false, sus ataques no se hacen nada entre sí.

Deja abierta la ventana Output (menú Window y luego Output) todo el tiempo. Estos scripts no imprimen nada cuando funcionan, así que cualquier error en rojo de SwordService o SwordClient es un problema real. Consulta Errores comunes.

Cómo ampliarlo a un sistema de combate

Combos

Lleva en el servidor un contador de ataques por jugador, junto a lastSwing. Si el ataque anterior fue reciente, suma 1; si no, empieza otra vez en 1. Luego elige el daño según la cuenta, por ejemplo más daño cada tercer golpe, y limpia el contador en PlayerRemoving de la misma forma. El cliente puede llevar su propia cuenta para elegir qué animación reproducir, porque la animación nunca decide un golpe. La caja y las comprobaciones siguen exactamente igual.

Empuje

Después de TakeDamage, SwordService puede empujar al objetivo con ApplyImpulse en el RootPart del objetivo, en la dirección del rootPart.CFrame.LookVector del atacante. La referencia de Roblox dice que el empuje depende de la masa del objetivo, y que un Script del servidor puede llamarlo en una parte que es del servidor o en una parte que es de un cliente de forma automática. El dispositivo de cada jugador simula su propio personaje, así que prueba el empuje con jugadores usando Server & Clients, no solo con un rig.

Crédito de bajas para un leaderboard

Justo antes de target:TakeDamage(DAMAGE), registra quién golpeó último con target:SetAttribute("LastHitBy", player.UserId). En un Script del servidor, conecta el evento Died del Humanoid de cada personaje, lee ese atributo, encuentra al atacante con Players:GetPlayerByUserId y suma 1 a un IntValue Kills en su leaderstats. Créalo junto a Coins y Wins como en el paso 1 de la guía del leaderboard, y cámbialo en el servidor como en el paso 2.

Bloqueo

Añade un segundo RemoteEvent que el cliente dispare cuando el botón de bloqueo se pulsa y se suelta, y haz que el servidor ponga un atributo Blocking en el personaje de ese jugador, con su propio límite de frecuencia. En SwordService, baja o sáltate el daño cuando el personaje del objetivo tenga Blocking puesto. Un tramposo igual elige cuándo bloquea, así que haz el bloqueo corto o dale un tiempo de espera.

Vender la espada o entregarla en cada ronda

StarterPack le da la espada a todos los jugadores en cada reaparición. Para venderla, ponla en la carpeta ShopItems de la guía de la GUI de tienda. El catálogo de esa guía ya vende una Tool llamada ClassicSword, así que llama ClassicSword a esta Tool y pon SWORD_NAME igual, o cambia la entrada del catálogo. Para entregarla solo durante una ronda, usa el script GiveRoundTool de la guía del sistema de rondas: guarda la Sword en ServerStorage y no en StarterPack, y cambia "RoundTool" en ese script por "Sword".

Enemigos contra los que pelear, y un arma a distancia

Para un NPC que persigue a los jugadores, sigue la guía de pathfinding para NPC. La espada lo daña como a cualquier otro Humanoid. Para un arma que golpea a distancia con las mismas reglas del servidor, consulta la guía del arma de fuego (en inglés).

Errores comunes y soluciones

Abre la ventana Output (menú Window y luego Output) antes de pulsar Play. La mayoría de los problemas con espadas imprimen ahí un error o vienen de un nombre que no coincide.

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

SwordClient está esperando el remote que crea SwordService, así que SwordService no se está ejecutando. Comprueba que es un Script, no un LocalScript, directamente dentro de ServerScriptService, que no está desactivado y que Output no muestra ningún error suyo.

Ataco pero nada recibe daño

Comprueba esto en orden: SwordClient es un LocalScript, no un Script, directamente dentro de la Tool Sword; la Tool se llama exactamente Sword, o lo que diga SWORD_NAME; el objetivo está a menos de 6 studs delante de ti; el objetivo apareció hace más de 10 segundos, así que su ForceField de aparición ya no está; y, si usas Teams, que no estás en el mismo equipo con FRIENDLY_FIRE en false.

La espada golpea a los jugadores pero nunca a mi NPC

Las consultas espaciales como GetPartBoundsInBox nunca devuelven una parte que tenga CanQuery desactivado (CanQuery solo tiene efecto cuando CanCollide también está desactivado). Vuelve a activar CanQuery en las partes del cuerpo del NPC, y comprueba que su Humanoid es hijo directo del modelo del NPC.

Mi personaje se queda atascado cuando equipo la espada

Alguna parte de la espada está anclada. Selecciona todas las partes de dentro de la Tool y desmarca Anchored.

Algunos ataques aciertan y otros fallan a la misma distancia

Con la versión con preparación, a un objetivo que sale de la caja durante WINDUP_SECONDS no se le acierta, y la comprobación de paredes se salta a quien esté detrás de una pared o de otro jugador. Baja la preparación, o aumenta HIT_WIDTH, si los fallos se sienten injustos en las pruebas de juego.

El personaje sujeta la espada por la hoja

Hay más de una parte llamada Handle, así que Roblox eligió la equivocada. Deja exactamente un Handle, la empuñadura, y cambia el nombre de las demás. Luego ajusta las propiedades de agarre de la Tool si el ángulo sigue mal.

La hoja se queda atrás o se cae cuando equipo la espada

La hoja no está soldada al Handle. Añade un WeldConstraint con Part0 en Handle y Part1 en la hoja.

El daño se ve en mi pantalla pero la vida del otro jugador no cambia

El daño se aplica desde un LocalScript, que cambia solo tu propia copia del juego. Aplica el daño solo en SwordService, como en el paso 2.

Constrúyelo con RoCode

Si prefieres no montar todo esto a mano, RoCode puede construirlo en el place que tienes abierto. Es un agente de programación con IA independiente, no lo hace Roblox: describes la función en su chat web y su plugin de Roblox Studio crea la Tool, las partes y los scripts en tu Explorer, así que no copias código desde una ventana de chat.

Tú escribes

Haz una espada: una Tool llamada Sword en StarterPack con un Handle y una hoja soldada a él, un LocalScript que dispare un RemoteEvent en Activated, y un Script del servidor que compruebe un cooldown de 0.6 segundos y haga 20 de daño a los Humanoids dentro de una caja delante del jugador.

RoCode hace
  • Crea la Tool y sus partes con Create Instance y pone sus propiedades con Set Property
  • Escribe SwordService y SwordClient con Create Script, y antes puede buscar scripts de combate que ya existan con Search Scripts
  • Tiene la instrucción de comprobar que cada script que escribe compila con Check Script, que compila el código en Studio sin ejecutarlo (no verifica los tipos)
  • Pone un punto de deshacer antes y después de cada lote de cambios, así que Ctrl+Z retrocede un lote cada vez

RoCode no puede hacer la animación del ataque ni subir una: hazla en el Animation Editor y pega su ID. Con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba, pero no hace clic en la vista 3D para atacar, así que los ataques los pruebas tú. Crear un juego entero de Roblox con RoCode, sistema por sistema muestra dónde encaja un arma. Cómo se conecta RoCode a Studio.

Preguntas frecuentes

¿Por qué mi espada golpea al mismo jugador varias veces en un solo ataque?

Porque aplica el daño desde Touched. La propia página de debounce de Roblox indica que Touched se dispara varias veces seguidas por un solo contacto, y cada parte del objetivo puede tocar la hoja. Esta guía encuentra los objetivos con una consulta de caja por ataque y lleva una lista, así que cada Humanoid pierde vida una vez por ataque.

¿El daño de la espada va en un LocalScript o en un Script?

En un Script del servidor. El daño aplicado desde un LocalScript cambia solo la copia del juego de ese jugador, y todo lo que está en el dispositivo del jugador lo puede cambiar un tramposo. El LocalScript solo debe detectar el clic, reproducir la animación y disparar el RemoteEvent.

¿Cómo le añado una animación de ataque a mi espada?

Hazla en el Animation Editor, pon su prioridad en Action, publícala en Roblox y pon su asset ID en SWING_ANIMATION_ID como rbxassetid:// seguido del número. SwordClient la reproduce con el Animator del personaje. Las animaciones que el dispositivo de un jugador empieza en el propio personaje de ese jugador se muestran a todos.

¿Por qué no se reproduce la animación de mi espada?

Comprueba tres cosas. La prioridad: Action está por encima de Movement, Idle y Core, así que un ataque con Action se reproduce por encima de caminar y de estar de pie, mientras que una prioridad más baja puede perder contra ellas. El dueño: si el juego pertenece a un grupo, publica la animación con ese grupo seleccionado como Creator. El ID: SWING_ANIMATION_ID debe ser el texto completo rbxassetid:// con el número de tu animación, no un string vacío.

¿Cuál es la mejor hitbox para una espada en Roblox?

Para la mayoría de los juegos, una consulta de caja en el servidor una vez por ataque, como en esta guía: una llamada a GetPartBoundsInBox, nada que un cliente pueda falsificar y tres números para ajustar. Usa GetPartsInPart con una parte con forma, o raycasts a lo largo de la hoja, solo cuando el alcance de un arma se parece poco a una caja. Los cuatro métodos comparados.

¿Cómo evito que mi espada golpee a través de las paredes?

Antes de aplicar el daño, lanza un rayo desde la parte raíz del atacante hasta la parte raíz del objetivo, saltándote el personaje del atacante, y cuenta el golpe solo si lo primero que encuentra el rayo pertenece al objetivo. La versión 2 de SwordService hace esto con cada objetivo.

¿Por qué el golpe llega antes de que la animación del ataque alcance al objetivo?

El servidor comprueba la hitbox en el momento en que llega el clic. Espera primero una preparación corta, por ejemplo 0.15 segundos con task.delay, luego comprueba que el atacante sigue vivo y con la espada en la mano y construye la caja, como hace la versión 2.

¿Los exploiters todavía pueden hacer trampa con esta espada?

No pueden elegir a quién se golpea, cuánto daño hace un golpe ni con qué frecuencia atacan, porque el servidor decide las tres cosas; lo máximo que ganan es el margen de red de 0.1 segundos sobre el tiempo de espera. Sí pueden mover su propio personaje, por ejemplo justo al lado de alguien, porque cada dispositivo controla el movimiento de su propio personaje. Una comprobación de movimiento en el servidor es la siguiente capa.

¿Cómo hago un sistema de combate con combos?

Lleva en el servidor un contador de ataques por jugador, reinícialo después de una pausa corta, y elige el daño y la animación según la cuenta. La comprobación del golpe sigue igual. Cómo ampliarlo también cubre el empuje, el crédito de bajas y el bloqueo.

Fuentes y lecturas

Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 12 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.