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
Touchedde 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.
TakeDamageno 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
Cómo encajan las piezas de una espada que funciona
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í:
- El jugador hace clic, toca la pantalla o pulsa el gatillo del mando con la Sword equipada.
Tool.Activatedse dispara en el LocalScript. - El LocalScript reproduce la animación del ataque, si hay una, y dispara el RemoteEvent
SwordSwing. No envía nada más. - El Script del servidor comprueba el tiempo de espera, que el jugador está vivo y que tiene la Sword en la mano.
- El servidor construye su propia hitbox delante del personaje del jugador y encuentra todos los Humanoids que hay dentro.
- Cada uno de esos Humanoids pierde vida una vez, mediante
TakeDamage.
| Pieza | Dónde va | Qué hace |
|---|---|---|
Tool Sword | StarterPack | Lo que sujeta el jugador. Roblox copia todo lo que hay en StarterPack al Backpack del jugador cada vez que aparece su personaje. |
Part Handle | Dentro de la Tool | La parte que agarra el personaje. La hoja está soldada a ella. |
LocalScript SwordClient | Dentro de la Tool | Detecta el clic, reproduce la animación del ataque y dispara el remote. |
RemoteEvent SwordSwing | ReplicatedStorage (lo crea SwordService) | Lleva el "ataqué" del dispositivo del jugador al servidor, sin argumentos. |
Script SwordService | ServerScriptService | Comprueba cada ataque, encuentra a quién hay delante del jugador y aplica el daño. Es el único lugar donde puede ocurrir un golpe. |
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
- 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. - 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. - Inserta una segunda Part en la Tool, llámala
Blade, y dale forma y posición para que sobresalga por arriba del Handle. - Inserta un WeldConstraint en Blade. En la ventana Properties, pon su
Part0en Handle y suPart1en Blade, para que la espada siga en una pieza mientras el jugador la lleva. - 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.
- Selecciona la Tool y desmarca CanBeDropped. Cuando está marcado, pulsar Retroceso suelta la espada en Workspace.
- 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.
-- 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.
| Ajuste | Valor 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. |
DAMAGE | 20 | La 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_SECONDS | 0.6 | El tiempo entre ataques. Pon el mismo valor en SwordClient. |
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT | 6, 5, 6 | La hitbox en studs: cuánto alcanza delante del jugador, qué ancho tiene y qué alto. |
FRIENDLY_FIRE | false | Cuando 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_SLACK | 0.1 | Cuá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 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.
| Paso | Código | Por qué |
|---|---|---|
| Saltarse al atacante | OverlapParams con Exclude y el personaje del atacante | Los brazos, las piernas y la espada del propio atacante también están dentro de la caja. |
| Encontrar el personaje | part: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 Humanoid | model: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 Humanoid | la tabla alreadyHit | Normalmente 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 vivos | target.Health > 0 | A un personaje que ya está derrotado no se le golpea otra vez. |
| Equipos | isTeammate | Con FRIENDLY_FIRE en false, se saltan los jugadores del mismo equipo. Un jugador cuya propiedad Neutral es true no tiene equipo. |
| Daño | target: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étodo | Cómo funciona | Quién decide | Precisión | Ideal para |
|---|---|---|---|---|
Touched en la hoja | Daño cada vez que la parte de la hoja toca un personaje | El dispositivo del atacante, que es dueño de su propio personaje y de su espada | Sigue la hoja, pero se dispara varias veces por contacto | Nada 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 ataque | El servidor | Una caja fija, no la trayectoria de la hoja. Los meshes cuentan por sus cajas delimitadoras, así que es un poco generosa | La mayoría de los juegos: simple, barata y sin nada que falsificar |
GetPartsInPart con una parte hitbox | Una consulta en el servidor con una parte con la forma del barrido de la hoja, durante el ataque | El servidor | Formas 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 baratas | Armas grandes con formas raras, como el arco de una guadaña |
| Raycasts a lo largo de la hoja | En cada frame del ataque, lanza rayos cortos desde puntos de la hoja hasta donde estaban en el frame anterior | El lado que los lance. En el servidor necesita la idea que tiene el servidor de dónde está la hoja | Sigue la animación de cerca | Juegos 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.
| Arma | DAMAGE | COOLDOWN_SECONDS | HIT_RANGE | HIT_WIDTH | Golpes (tiempo) | Daño por segundo |
|---|---|---|---|---|---|---|
| Daga | 12 | 0.35 | 4 | 4 | 9 (2.8 s) | unos 34 |
| Espada (esta guía) | 20 | 0.6 | 6 | 5 | 5 (2.4 s) | unos 33 |
| Espadón | 35 | 1.1 | 7 | 7 | 3 (2.2 s) | unos 32 |
| Lanza | 18 | 0.8 | 9 | 3 | 6 (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 (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.delayejecutastrikeWINDUP_SECONDSdespués.strikecomprueba 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,
hasClearLinelanza 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:
- 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.
- 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.
- 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.
- 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.
- Copia el asset ID de la animación desde la Toolbox, y en SwordClient pon
SWING_ANIMATION_IDen"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.
| El tutorial | El problema | Esta guía |
|---|---|---|
Aplica el daño en el evento Touched de la hoja | El 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 LocalScript | Un 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 espera | Roblox 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:LoadAnimation | Obsoleto; lo reemplaza Animator:LoadAnimation. | Carga el ataque a través del Animator. |
Encuentra los objetivos con Region3 y FindPartsInRegion3 | Obsoleto. Roblox dice que uses GetPartBoundsInBox con OverlapParams en el trabajo nuevo. | Usa GetPartBoundsInBox. |
Pone dentro de la Tool un Script del servidor que escucha Activated | La 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.
| El tramposo intenta | Resultado | Por qué |
|---|---|---|
Disparar SwordSwing tan rápido como pueda su código, o usar un auto-clicker | Como máximo cuenta un ataque cada 0.5 segundos | El 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 remote | Se ignora | onSwing 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 espera | Sin efecto en el servidor | SwordService guarda sus propios ajustes en ServerScriptService, que nunca se envía a los jugadores. |
| Atacar estando muerto, o sin la espada en la mano | Se ignora | SwordService 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 mapa | No pasa nada | La 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 atacar | Posible | Cada 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 fina | Posible dentro de la caja de 6 studs | La 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 ninguna | Sin efecto en los golpes | Los 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
- 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.
- 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.
- Haz clic tan rápido como puedas. Solo un ataque cada 0.6 segundos hace algo.
- 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.
- 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.
- Si tu juego usa Teams, pon a los dos jugadores de prueba en el mismo equipo. Con
FRIENDLY_FIREen 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.
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.
- 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
- Roblox Creator Docs: In-game tools (en inglés). construir una tool en Workspace, el Handle, soldar, Grip, el anclaje, y por qué la mayoría de las tools usan un LocalScript, un Script y un RemoteEvent
- Roblox Creator Docs: WorldRoot:GetPartBoundsInBox (en inglés). la consulta de caja, OverlapParams y el obsoleto FindPartsInRegion3
- Roblox Creator Docs: Humanoid:TakeDamage (en inglés). la protección del ForceField, la barra de vida y la regeneración de vida
- Roblox Creator Docs: Network ownership (en inglés). el exploit de la espada con Touched
- Roblox Creator Docs: Security tactics and cheat mitigation (en inglés). nunca confíes en el cliente
- Roblox Creator Docs: Network ownership, movement validation and physics exploits (en inglés). qué puede hacer un cliente con su propio personaje, y las comprobaciones de movimiento
- Roblox Creator Docs: Animation Editor (en inglés). prioridad de animación y publicación
- Roblox Creator Docs: Animator:LoadAnimation (en inglés). qué animaciones se replican desde el cliente
- Roblox Creator Docs: Debounce patterns (en inglés). por qué Touched se dispara varias veces por un solo contacto
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.