Tutorial · Sistemi di gioco

Come fare una spada in Roblox Studio

Una spada su Roblox è un Tool con tre compiti divisi tra due script: il dispositivo del giocatore nota il clic e riproduce il fendente, e il server decide chi è stato colpito e quanta salute ha perso. In questa guida costruiamo entrambi gli script, con un cooldown e una hitbox che i giocatori non possono falsificare, e mostriamo dove va l'animazione.

Aggiornato il 20 novembre 202625 min di letturaScritto da

In breve

Metti in StarterPack un Tool chiamato Sword con una parte chiamata Handle. Un LocalScript nel Tool ascolta Tool.Activated, riproduce l'animazione del fendente e chiama un RemoteEvent senza argomenti. Uno Script in ServerScriptService controlla il cooldown e che il giocatore sia vivo e impugni la spada, trova gli Humanoid nel box davanti a lui con workspace:GetPartBoundsInBox e chiama Humanoid:TakeDamage una volta per bersaglio.

  • Non infliggere danno dall'evento Touched della lama: il dispositivo del giocatore controlla il proprio personaggio e può far scattare Touched da qualsiasi punto, e la spada è proprio l'esempio citato nella pagina di Roblox sul network ownership.
  • Il client non invia né il bersaglio né il danno. Cooldown, hitbox e quantità di danno sono del server.
  • TakeDamage non fa nulla finché il bersaglio ha un ForceField, per esempio nei primi 10 secondi dopo lo spawn su uno SpawnLocation.
  • I colpi passano attraverso i muri o arrivano prima che il fendente raggiunga visivamente il bersaglio? Usa la versione dello script del server con caricamento del colpo e controllo dei muri.
In questa pagina
  1. Come è fatta
  2. 1. Costruire il Tool
  3. 2. Script del server
  4. 3. LocalScript
  5. Hitbox
  6. Tipi di hitbox
  7. Caricamento e controllo muri
  8. Animazione del fendente
  9. Vecchi tutorial
  10. Limiti della protezione
  11. 4. Prova
  12. Estensioni
  13. Common errors
  14. Con RoCode
  15. Domande frequenti
  16. Fonti e letture

Come è fatta una spada che funziona

IllustrazioneI fendenti distanziati di almeno 0.6 secondi tolgono 20 di salute ciascuno, un clic dentro il cooldown non fa nulla e il quinto colpo mette fuori gioco il rig.

Una spada che funziona in un gioco vero è divisa tra il dispositivo del giocatore e il server. La pagina di Roblox sui tool dice che l'input dei tool deve stare in un LocalScript, perché solo il dispositivo del giocatore sa quando avviene l'input, e che la maggior parte dei tool ha bisogno di un LocalScript, di uno Script lato server e di un RemoteEvent tra i due. Questa guida usa proprio questa divisione. Un fendente funziona così:

  1. Il giocatore clicca, tocca lo schermo o preme il grilletto del gamepad con Sword equipaggiata. Nel LocalScript scatta Tool.Activated.
  2. Il LocalScript riproduce l'animazione del fendente, se c'è, e chiama il RemoteEvent SwordSwing. Non invia nient'altro.
  3. Lo Script del server controlla il cooldown, che il giocatore sia vivo e che abbia Sword in mano.
  4. Il server costruisce la propria hitbox davanti al personaggio del giocatore e trova ogni Humanoid al suo interno.
  5. Ognuno di questi Humanoid perde salute una volta tramite TakeDamage.
Di cosa è fatta la spada
ElementoDove si trovaCosa fa
Tool SwordStarterPackQuello che impugna il giocatore. Roblox copia tutto da StarterPack nel Backpack del giocatore a ogni spawn del suo personaggio.
Part HandleDentro il ToolLa parte per cui il personaggio impugna la spada. La lama è saldata a questa.
LocalScript SwordClientDentro il ToolSente il clic, riproduce l'animazione del fendente e chiama il remote.
RemoteEvent SwordSwingReplicatedStorage (lo crea SwordService)Porta «ho fatto un fendente» dal dispositivo del giocatore al server, senza argomenti.
Script SwordServiceServerScriptServiceControlla ogni fendente, trova chi sta davanti al giocatore e infligge il danno. L'unico posto in cui può avvenire un colpo.
L'Explorer quando la spada è pronta. SwordService aggiunge un RemoteEvent chiamato SwordSwing in ReplicatedStorage quando il gioco è avviato.
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

Passo 1: costruisci il Tool della spada

  1. Nell'Explorer passa il mouse su Workspace, premi il pulsante + e inserisci un Tool. Rinominalo Sword. Lo script del server cerca proprio questo nome. Costruisci la spada in Workspace, come consiglia la pagina di Roblox sui tool, perché lì vedi le sue parti e puoi spostarle e ridimensionarle. L'ultimo passo la sposta in StarterPack.
  2. Inserisci nel Tool una Part e chiamala Handle. È l'impugnatura con cui il personaggio tiene la spada. Deve essere figlia diretta del Tool e l'unica parte con quel nome: con due Handle Roblox ne sceglie una a caso, e il personaggio potrebbe impugnare la spada per la lama.
  3. Inserisci nel Tool una seconda Part, chiamala Blade, dalle una forma e posizionala in modo che esca dalla cima di Handle.
  4. Inserisci in Blade un WeldConstraint. Nella finestra Properties imposta il suo Part0 su Handle e Part1 su Blade, così la spada resta intera mentre il giocatore la porta.
  5. Seleziona entrambe le parti e verifica che Anchored sia disattivato. Una parte ancorata in un tool inchioda il personaggio sul posto quando lo equipaggia. Disattiva su entrambe anche CanCollide, così la lama non urta giocatori e muri durante il fendente.
  6. Seleziona il Tool e togli la spunta da CanBeDropped. Quando è attiva, premere Backspace fa cadere la spada in Workspace.
  7. Trascina la Sword finita da Workspace in StarterPack. Un Tool lasciato in Workspace è un oggetto da raccogliere che prende un solo giocatore, non una spada che ognuno ha nel Backpack fin dall'inizio.

Va bene anche una spada fatta da un solo MeshPart: chiama quel MeshPart Handle e salta la saldatura. Se nel test il personaggio impugna la spada con un angolo strano, seleziona il Tool e regola le sue proprietà di impugnatura (GripPos, GripForward, GripRight e GripUp) nella finestra Properties.

Passo 2: aggiungi lo script del server

Passa il mouse su ServerScriptService, inserisci uno Script chiamato SwordService e incollaci il codice qui sotto. È l'unico posto in cui può avvenire un colpo di spada. Le impostazioni all'inizio sono le righe che sei fatto per cambiare.

Script in ServerScriptService chiamato SwordService
-- Script in ServerScriptService chiamato SwordService.
-- L'unico posto in cui può avvenire un colpo di spada: controlla il fendente, trova i bersagli davanti
-- all'attaccante con la propria hitbox e infligge il danno.

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

-- Impostazioni
local SWORD_NAME = "Sword" -- nome del Tool in StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- tieni lo stesso valore in SwordClient
local HIT_RANGE = 6 -- stud davanti all'attaccante
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false: i giocatori della stessa squadra non possono ferirsi a vicenda
-- I fendenti inviati esattamente a COOLDOWN_SECONDS di distanza, dopo il ritardo di rete, possono arrivare
-- un po' più vicini, quindi il server concede questo margine e non scarta un fendente vero
local NETWORK_SLACK = 0.1

-- Il remote che chiama il LocalScript della spada. Non porta argomenti: chi viene colpito
-- lo decide il server, quindi il client non ha niente da falsificare.
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
	-- I giocatori neutrali (senza squadra) possono sempre colpirsi a vicenda
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

local function onSwing(player: Player)
	-- 1. Un fendente per cooldown, per quanto spesso venga chiamato il remote
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end

	-- 2. L'attaccante deve essere vivo e impugnare la spada
	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 del server: un box davanti alla parte radice dell'attaccante
	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. Ogni Humanoid nel box subisce danno una volta, anche se dentro ci sono più sue parti
	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) -- non fa nulla finché il bersaglio ha un ForceField
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(onSwing)

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

SwordService crea da solo il RemoteEvent SwordSwing all'avvio del gioco, quindi non devi inserire nulla a mano in ReplicatedStorage. Se hai già creato un RemoteEvent con questo nome, eliminalo: il LocalScript potrebbe trovare il tuo, e sul server nessuno lo ascolta.

Le impostazioni all'inizio di SwordService
ImpostazioneValore quiCosa cambia
SWORD_NAME"Sword"Il nome del Tool che il server si aspetta in mano al giocatore. Cambialo se il tuo Tool ha un altro nome.
DAMAGE20Quanta salute toglie ogni colpo. Un Humanoid parte con 100 di salute, quindi cinque colpi mettono fuori gioco il rig di prova. I personaggi dei giocatori di default recuperano l'1% di MaxHealth ogni secondo, quindi un giocatore colpito alla massima velocità sopravvive al quinto colpo e ne serve un sesto.
COOLDOWN_SECONDS0.6Il tempo tra un fendente e l'altro. Imposta lo stesso valore in SwordClient.
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6La hitbox in stud: quanto lontano arriva davanti al giocatore, quanto è larga e quanto è alta.
FRIENDLY_FIREfalseCon false i giocatori della stessa squadra non possono ferirsi a vicenda. I giocatori senza squadra possono sempre colpirsi, e gli NPC si possono sempre colpire.
NETWORK_SLACK0.1Quanto prima della fine del cooldown il server accetta ancora un fendente. Due clic a 0.6 secondi di distanza, dopo il ritardo di rete, possono arrivare un po' più vicini, e senza questo margine il server scarterebbe un fendente vero che il giocatore ha già visto.

Passo 3: aggiungi il LocalScript nel Tool

Inserisci nel Tool Sword un LocalScript, chiamalo SwordClient e incollaci questo codice:

LocalScript in Tool Sword in StarterPack chiamato SwordClient
-- LocalScript dentro il Tool Sword chiamato SwordClient.
-- Tool.Activated scatta sul dispositivo del giocatore, quindi questo script ascolta il clic,
-- il tocco o il grilletto, riproduce l'animazione del fendente e chiede al server di fare il fendente.

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 -- lo stesso valore di SwordService
local SWING_ANIMATION_ID = "" -- facoltativo: "rbxassetid://" seguito dall'id della tua animazione

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

-- Carichiamo l'animazione una volta per personaggio. Le animazioni avviate sul tuo stesso
-- personaggio dal tuo dispositivo si vedono da tutti i giocatori.
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 -- lo controlla anche il server; il controllo qui evita richieste inutili
	end
	lastSwing = now
	if swingTrack then
		swingTrack:Play()
	end
	swingEvent:FireServer()
end)

Per ora lascia vuoto SWING_ANIMATION_ID. La spada funziona anche senza animazione, perché il colpo lo decide comunque il server. Come compilarlo è mostrato nella sezione Aggiungi l'animazione del fendente.

Activated scatta con il clic del mouse, il tocco sul telefono e il grilletto del gamepad, quindi lo stesso script funziona su qualsiasi dispositivo. Roblox copia il Tool e il LocalScript al suo interno nel Backpack di ogni giocatore allo spawn del suo personaggio, quindi ogni giocatore ha la sua copia in esecuzione.

Il LocalScript tiene un proprio cooldown solo per non inviare richieste che il server ignorerebbe comunque. Non è un controllo di sicurezza: un cheater può eliminarlo, modificarlo o chiamare SwordSwing dal proprio codice. La guida ai RemoteEvent spiega perché ogni remote va controllato sul server, e Script vs LocalScript vs ModuleScript (in inglese) mostra cosa un LocalScript può e non può cambiare.

Come il server decide chi è stato colpito

Quando arriva SwordSwing, SwordService non chiede nulla al client. Costruisce un box davanti al personaggio dell'attaccante, là dove lo vede il server, e chiede al motore quali parti si trovano dentro, con workspace:GetPartBoundsInBox. Questo metodo sostituisce il più vecchio FindPartsInRegion3, che Roblox indica come deprecato.

Il centro del box si trova 3 stud davanti alla parte radice dell'attaccante. È lo spostamento CFrame.new(0, 0, -HIT_RANGE / 2): un CFrame guarda lungo il proprio asse Z negativo, che è il suo LookVector. Quindi il box si estende dal centro del personaggio per 6 stud in avanti, ed è largo 5 stud e alto 6. La query confronta il riquadro di delimitazione (bounding box) di ogni parte, un'approssimazione veloce del suo volume a forma di scatola, quindi le parti rotonde e le mesh contano un po' più grandi di come appaiono. Per una spada questo piccolo margine è utile.

Cosa fa SwordService con le parti nel box
PassoCodicePerché
Saltare l'attaccanteOverlapParams con Exclude e il personaggio dell'attaccanteAnche braccia, gambe e spada dell'attaccante si trovano nel box.
Trovare il personaggiopart:FindFirstAncestorOfClass("Model")Una parte nel box può essere un arto, un cappello o un tool in mano. FindFirstAncestorOfClass confronta il nome esatto della classe, quindi supera il cappello (classe Accessory) e il tool in mano (classe Tool, anche se Tool è un tipo di Model) e si ferma sul modello del personaggio.
Trovare l'Humanoidmodel:FindFirstChildOfClass("Humanoid")Si può colpire tutto ciò che ha un Humanoid: giocatori, NPC e manichini di prova. Muri e pavimenti vengono saltati.
Una volta per Humanoidla tabella alreadyHitNel box di solito finiscono più parti dello stesso personaggio. Senza la tabella, ognuna infliggerebbe danno di nuovo.
Solo bersagli vivitarget.Health > 0Un personaggio già messo fuori gioco non viene colpito di nuovo.
SquadreisTeammateCon FRIENDLY_FIRE uguale a false i giocatori della stessa squadra vengono saltati. Un giocatore con la proprietà Neutral uguale a true non ha squadra.
Dannotarget:TakeDamage(DAMAGE)Abbassa Health, se il bersaglio non è protetto da un ForceField.

La tabella alreadyHit viene creata di nuovo a ogni fendente, quindi lo stesso giocatore può essere colpito ancora dal fendente successivo, quando il cooldown è passato. È proprio la regola «una volta per bersaglio per fendente» con cui le spade basate su Touched hanno sempre problemi.

Lo script usa TakeDamage, non un'assegnazione di Health. Il riferimento di Roblox dice che TakeDamage non tocca un Humanoid finché lo protegge un ForceField, mentre assegnare Health direttamente ignora il ForceField. Un giocatore che fa spawn su uno SpawnLocation riceve di default un ForceField per 10 secondi (la Duration dello SpawnLocation), quindi chi è appena arrivato non può essere colpito nel momento in cui compare.

Quattro modi di fare la hitbox di una spada: confronto

I tutorial sulle spade differiscono soprattutto su una cosa: come sapere cosa ha colpito la lama. Ci sono quattro risposte diffuse. Si distinguono per quanto seguono fedelmente la lama, quanto lavoro costano al server e se un cheater può falsificarne il risultato.

Modi di fare la hitbox di una spada. «Chi decide» è la parte la cui risposta conta
MetodoCome funzionaChi decidePrecisionePer cosa è migliore
Touched sulla lamaDanno ogni volta che una parte della lama tocca un personaggioIl dispositivo dell'attaccante, che possiede il proprio personaggio e la spadaSegue la lama, ma scatta più volte per contattoNiente in un gioco con altri giocatori: il dispositivo dell'attaccante può farlo scattare da qualsiasi punto
Box davanti al giocatore (questa guida)Una query GetPartBoundsInBox sul server per fendenteIl serverUn box fisso, non il percorso della lama. Le mesh contano per i loro bounding box, quindi è un po' generosoLa maggior parte dei giochi: semplice, economico e niente da falsificare
GetPartsInPart su una parte hitboxUna query lato server con una parte a forma dell'arco della lama, durante il fendenteIl serverForme precise: la documentazione di Roblox dice che fa un controllo geometrico completo, e suggerisce le query per box o sfera quando basta meno precisione, perché costano menoArmi grandi dalla forma insolita, come l'arco di una falce
Raycast lungo la lamaA ogni frame del fendente brevi raggi partono da punti sulla lama verso dove si trovavano nel frame precedenteLa parte che li lancia. Sul server serve una rappresentazione lato server di dove sia la lamaSegue da vicino l'animazioneGiochi dove conta il percorso preciso del fendente. Così funzionano i moduli hitbox della community

Il box è la prima scelta giusta. È una query per fendente, non dipende mai da un'animazione che un cheater potrebbe modificare e si regola facilmente con tre numeri. Passa a una parte della forma giusta o ai raggi lungo la lama quando i giocatori si lamentano che i colpi sembrano sbagliati con armi la cui portata è lontana da un box, e mantieni la stessa regola: la query la esegue e il danno lo infligge il server.

Preset delle spade: dal pugnale allo spadone

Lo stesso SwordService crea armi molto diverse con cinque impostazioni. La tabella è un punto di partenza, calcolato per un manichino del Rig Generator con 100 Health. Il «tempo al KO» si conta dal primo colpo, quando ogni fendente colpisce non appena il cooldown lo permette.

Impostazioni di SwordService per le armi da mischia più comuni, con numero di colpi e tempo per mettere KO un manichino con 100 Health. Calcolato, non misurato
ArmaDAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTHColpi (tempo)Danno al secondo
Pugnale120.35449 (2.8 s)circa 34
Spada (questa guida)200.6655 (2.4 s)circa 33
Spadone a due mani351.1773 (2.2 s)circa 32
Lancia180.8936 (4 s)circa 23
  • I giocatori si curano, i manichini no. I personaggi dei giocatori di default recuperano l'1% di MaxHealth ogni secondo. Con esattamente 100 di danno in 5 colpi, un giocatore colpito alla massima velocità sopravvive al quinto colpo e ne serve un sesto. Lascia un margine, per esempio 21 di danno invece di 20, se conta il numero esatto di colpi.
  • Scala NETWORK_SLACK insieme al cooldown. Lo 0.1 secondi della guida è un sesto di 0.6. Se lasci 0.1 su un pugnale con cooldown di 0.35 secondi, un cheater potrebbe colpire ogni 0.25 secondi, il 40% più veloce. Usa circa un sesto di COOLDOWN_SECONDS: 0.06 per il pugnale.
  • Tieni SwordClient allineato. Imposta lì lo stesso COOLDOWN_SECONDS, altrimenti il client invia fendenti che il server ignora.

Versione 2: caricamento del colpo e niente colpi attraverso i muri

Quando la spada base funziona, arrivano due lamentele. Il colpo arriva nello stesso istante in cui il giocatore clicca, prima che l'animazione del fendente raggiunga il bersaglio, e il fendente può colpire chi sta dall'altra parte di un muro sottile, perché il box non tiene conto dei muri. Questa versione di SwordService corregge entrambe le cose. Sostituisce lo script del passo 2: stesso nome, stesso remote, stesse impostazioni, quindi SwordClient non va cambiato.

Script in ServerScriptService chiamato SwordService
-- Script in ServerScriptService chiamato SwordService (versione con caricamento e controllo dei muri).
-- Sostituisce lo script del passo 2: stesse impostazioni e stesso remote più due regole. Il colpo arriva
-- WINDUP_SECONDS dopo il clic, quando il fendente raggiunge il bersaglio, e non colpisce nessuno
-- attraverso un muro.

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

-- Impostazioni
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- tieni lo stesso valore in SwordClient
local WINDUP_SECONDS = 0.15 -- tempo dal clic al colpo; adattalo alla tua animazione del fendente
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

-- Restituisce il personaggio e la parte radice dell'attaccante, finché è vivo e impugna la spada
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 tra l'attaccante e il bersaglio non c'è nulla tranne il bersaglio stesso
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)
	-- Ricontrolliamo dopo il caricamento: l'attaccante potrebbe essere morto o aver riposto la spada
	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)

Prima elimina il SwordService del passo 2, altrimenti entrambi gli script creeranno un remote SwordSwing ciascuno. Imposta WINDUP_SECONDS sul momento della tua animazione in cui la lama passa davanti al personaggio; per un fendente veloce va bene 0.15.

  • Caricamento. Il cooldown e i controlli «vivo e impugna la spada» avvengono quando arriva il clic, poi task.delay avvia strike dopo WINDUP_SECONDS. strike controlla di nuovo l'attaccante, perché nel frattempo potrebbe essere morto o aver riposto la spada, e solo dopo costruisce il box. Un bersaglio uscito dalla portata durante il caricamento non viene colpito, ed è proprio quello che i giocatori si aspettano quando vedono il fendente.
  • Controllo dei muri. Per ogni bersaglio nel box, hasClearLine lancia un raggio dalla parte radice dell'attaccante alla parte radice del bersaglio, saltando il personaggio dell'attaccante. Se la prima cosa che incontra appartiene al bersaglio, o non incontra nulla, il colpo conta. Un muro, una porta o un altro giocatore in mezzo lo bloccano.
  • Quanto costa. Un raggio in più per bersaglio per fendente, poco rispetto alla query del box stessa.

Il caricamento rende la spada anche più equa contro i cheater che colpiscono nello stesso istante in cui si teletrasportano accanto a qualcuno: il server cerca i bersagli un attimo dopo, là dove vede i personaggi in quel momento. Il teletrasporto in sé non viene fermato; per quello serve il controllo del movimento descritto nella sezione Cosa può e non può fare un exploiter.

Aggiungi l'animazione del fendente (facoltativo)

SwordClient riproduce già l'animazione non appena gli dai un ID. L'animazione la crei una volta, nell'Animation Editor di Studio:

  1. Inserisci un rig da animare. Nella scheda Avatar o Home premi Character per aprire il Rig Generator e scegli un rig che corrisponde agli avatar del tuo gioco, per esempio R15 e poi Block Avatar.
  2. Nella scheda Avatar premi Clip Editor per aprire l'Animation Editor, seleziona il rig e crea le pose per un breve fendente con il braccio destro.
  3. Imposta la priorità Action: premi il pulsante … nei controlli di riproduzione dell'editor, passa il mouse su Set Animation Priority e scegli Action. Action sta sopra Movement, Idle e Core, quindi il fendente viene riprodotto sopra le animazioni di camminata e di attesa, invece di essere sovrascritto da loro.
  4. Nello stesso menu … scegli Publish to Roblox. Se il tuo gioco appartiene a un gruppo, scegli quel gruppo nel campo Creator prima di inviare.
  5. Copia l'asset ID dell'animazione dalla Toolbox e in SwordClient imposta SWING_ANIMATION_ID su "rbxassetid://" seguito da quel numero.

SwordClient carica il fendente tramite l'Animator del personaggio, non con il più vecchio Humanoid:LoadAnimation, che Roblox indica come deprecato. Il riferimento di Roblox su Animator dice che le animazioni che il dispositivo di un giocatore avvia sul personaggio di quel giocatore si replicano sul server e su tutti gli altri giocatori, quindi un LocalScript può riprodurre il fendente e lo vedranno tutti. Lì è scritto anche che l'Animator va creato sul server, quindi non crearlo mai in un LocalScript. Nei personaggi dei giocatori di solito si trova dentro l'Humanoid, ed è proprio lì che lo cerca l'esempio di animazione di Roblox.

L'animazione serve solo per l'aspetto. I colpi non dipendono da lei, quindi un'animazione lenta, assente o modificata non cambia mai chi viene colpito.

Per riprodurre un'animazione alla pressione di un tasto, in loop o su un NPC, leggi la guida allo script di animazione.

Dove sbagliano i vecchi tutorial sulle spade

Se confronti questa guida con un video o un post sul forum, ecco le differenze importanti e il motivo per cui ogni tecnica crea un problema.

Tecniche comuni nei tutorial sulle spade e cosa fa questa guida al loro posto
TutorialProblemaQuesta guida
Infligge danno nell'evento Touched della lamaIl dispositivo dell'attaccante può far scattare Touched sulla propria spada da qualsiasi punto (pagina di Roblox sul network ownership), e Touched scatta più volte di fila per un solo contatto (pagina di Roblox sul debounce).Il server trova i bersagli con il proprio box, una volta per Humanoid per fendente.
Abbassa Health in un LocalScriptUna modifica che un LocalScript fa al personaggio di un altro resta su quel solo dispositivo.Tutto il danno viene inflitto in SwordService.
Usa wait(0.5) per il cooldownRoblox indica il wait() globale come deprecato, al suo posto si usa task.wait(), e un cooldown che esiste solo sul client non ferma nessuno.Confronta il tempo di os.clock() sul server. Niente aspetta.
Riproduce il fendente con Humanoid:LoadAnimationDeprecato, al suo posto si usa Animator:LoadAnimation.Carica il fendente tramite l'Animator.
Cerca i bersagli con Region3 e FindPartsInRegion3Deprecato. Roblox consiglia nei nuovi progetti di usare GetPartBoundsInBox con OverlapParams.Usa GetPartBoundsInBox.
Mette uno Script lato server dentro il Tool, che ascolta ActivatedLa spada di ogni giocatore esegue la propria copia del codice del server, e questi script spesso infliggono danno in Touched (prima riga). Con le impostazioni predefinite uno Script funziona solo in Workspace o ServerScriptService, quindi uno Script nel Tool non parte finché la spada non viene equipaggiata la prima volta. La pagina di Roblox sui tool descrive la maggior parte dei tool come un LocalScript per l'input, uno Script lato server per l'effetto e un RemoteEvent tra i due.Un solo SwordService in ServerScriptService gestisce tutte le spade del gioco.

Cosa può e non può fare un exploiter

Considera che un cheater controlla tutto sul proprio dispositivo. Può leggere e modificare i tuoi LocalScript, e la guida di Roblox sulla sicurezza dice che può chiamare i RemoteEvent con qualsiasi frequenza e argomenti arbitrari. Ecco cosa significa per questa spada.

Cosa può tentare un cheater e cosa ne fa SwordService
Il cheater tenta diRisultatoPerché
Chiamare SwordSwing veloce quanto può il suo codice, o usare un autoclickerConta al massimo un fendente ogni 0.5 secondiIl cooldown del server è 0.6 secondi meno 0.1 secondi di margine di rete. Quel margine è il massimo che guadagna un cheater.
Inviare con il remote un bersaglio, un valore di danno o una posizioneIgnoratoonSwing legge solo il giocatore che Roblox inserisce da solo. Tutto il resto inviato con il remote non viene mai letto.
Modificare SwordClient, per esempio togliendo il suo cooldownNessun effetto sul serverSwordService tiene le sue impostazioni in ServerScriptService, che non viene mai inviato ai giocatori.
Colpire da morto o senza la spada in manoIgnoratoSwordService controlla che il suo Humanoid sia vivo e che un Tool chiamato Sword si trovi dentro il suo personaggio, dove Roblox sposta il tool quando viene equipaggiato.
Colpire qualcuno dall'altro capo della mappaNon succede nullaIl box viene costruito attorno al personaggio dell'attaccante, là dove lo vede il server, e arriva solo a 6 stud in avanti.
Teletrasportarsi accanto a un giocatore e poi colpirePossibileOgni dispositivo controlla il movimento del proprio personaggio, e Roblox elenca il teletrasporto in qualsiasi punto tra le cose che un client può fare con il proprio personaggio. Un controllo del movimento sul server può rilevarlo.
Colpire attraverso un muro sottilePossibile entro il box di 6 studLa query del box del passo 2 non cerca i muri. La versione 2 aggiunge il controllo dei muri.
Riprodurre qualsiasi animazione o nessunaNessun effetto sui colpiI colpi non dipendono mai dall'animazione. Roblox nota che i cheater possono riprodurre animazioni arbitrarie sul proprio personaggio.

In due righe c'è «Possibile», ed è onesto. Questa spada non lascia che un cheater scelga chi colpisce, quanto forte e quanto spesso. Non può impedirgli di muovere il proprio personaggio. La documentazione di Roblox sulla sicurezza dice che i client controllano il movimento e la fisica del proprio personaggio e che i controlli del movimento vanno regolati per ogni gioco. Per un gioco competitivo il livello successivo è un controllo del movimento sul server (la guida allo sprint ne costruisce uno, che segnala gli speedhack grossolani e i teletrasporti lunghi) oppure la server authority di Roblox, che la documentazione descriveva come beta quando abbiamo controllato il 13 ottobre 2026.

Passo 4: provala

  1. Aggiungi qualcosa da colpire. Nella scheda Avatar o Home premi Character per aprire il Rig Generator, scegli un rig (per esempio R15, poi Block Avatar) e verrà inserito in Workspace. Spostalo qualche stud lontano dal tuo SpawnLocation.
  2. Premi Play, equipaggia Sword dalla hotbar, avvicinati al rig e clicca. Dopo il primo colpo sopra di lui compare la barra della salute, perché di default un Humanoid mostra la barra solo quando la sua Health è sotto MaxHealth. Un Humanoid parte con 100 di salute, quindi il quinto colpo lo mette fuori gioco.
  3. Clicca più veloce che puoi. Ha effetto solo un fendente ogni 0.6 secondi.
  4. Allontanati dal rig di circa 8 stud o giragli le spalle e fai un fendente. Non succede nulla, perché nessuna sua parte si trova nel box.
  5. Prova su un giocatore vero. Scegli Server & Clients nel menu a tendina delle modalità di test, imposta 2 client e premi Play. Colpisci l'altro giocatore entro 10 secondi dal suo spawn: non succede nulla per via del ForceField di spawn. Dopo, ogni colpo toglie 20. Di default i personaggi dei giocatori recuperano anche l'1% di MaxHealth ogni secondo, quindi tra un combattimento e l'altro la loro salute torna un po' alla volta.
  6. Se il tuo gioco ha Teams, metti entrambi i giocatori di prova nella stessa squadra. Con FRIENDLY_FIRE uguale a false i loro fendenti non si fanno nulla a vicenda.

Per tutto il tempo tieni aperta la finestra Output (menu Window, poi Output). Quando questi script funzionano non stampano nulla, quindi qualsiasi errore rosso di SwordService o SwordClient è un problema vero. Vedi Errori comuni.

Come estendere la spada in un sistema di combattimento

Combo

Tieni sul server un contatore di fendenti per giocatore, accanto a lastSwing. Se il fendente precedente è stato poco fa, aggiungi 1; altrimenti ricomincia da 1. Poi scegli il danno in base al contatore, per esempio più danno a ogni terzo colpo, e svuota il contatore su PlayerRemoving allo stesso modo. Il client può tenere il proprio conteggio per scegliere quale animazione riprodurre, perché l'animazione non decide mai il colpo. Il box e i controlli restano esattamente uguali.

Contraccolpo

Dopo TakeDamage SwordService può spingere via il bersaglio con ApplyImpulse sulla RootPart del bersaglio, nella direzione del rootPart.CFrame.LookVector dell'attaccante. Il riferimento di Roblox dice che la spinta dipende dalla massa del bersaglio e che uno Script lato server può chiamarla su una parte posseduta dal server o su una parte posseduta automaticamente da un client. Il dispositivo di ogni giocatore simula il proprio personaggio, quindi prova il contraccolpo sui giocatori con Server & Clients, non solo sul rig.

Uccisioni per la classifica

Subito prima di target:TakeDamage(DAMAGE) registra chi ha colpito per ultimo con target:SetAttribute("LastHitBy", player.UserId). In uno Script lato server collega l'evento Died dell'Humanoid di ogni personaggio, leggi quell'attributo, trova l'attaccante con Players:GetPlayerByUserId e aggiungi 1 all'IntValue Kills nei suoi leaderstats. Crealo accanto a Coins e Wins, come nel passo 1 della guida alla classifica, e modificalo sul server, come nel passo 2.

Parata

Aggiungi un secondo RemoteEvent che il client chiama quando il pulsante di parata viene premuto e rilasciato, e fai impostare al server un attributo Blocking sul personaggio di quel giocatore, con un suo limite di frequenza. In SwordService riduci o salta il danno quando il personaggio del bersaglio ha Blocking impostato. Il cheater sceglie comunque da solo quando parare, quindi rendi la parata breve o dalle un cooldown.

Vendere la spada o darla a ogni round

StarterPack dà la spada a ogni giocatore a ogni spawn. Per venderla invece, mettila nella cartella ShopItems della guida alla GUI del negozio. Il catalogo di quella guida vende già un Tool chiamato ClassicSword, quindi o chiami questo Tool ClassicSword e imposti lo stesso SWORD_NAME, o modifichi la voce nel catalogo. Per darla solo per la durata di un round, prendi lo script GiveRoundTool dalla guida al sistema di round: tieni Sword in ServerStorage, non in StarterPack, e sostituisci "RoundTool" in quello script con "Sword".

Nemici da combattere e armi a distanza

Per un NPC che insegue i giocatori, segui la guida al pathfinding degli NPC. La spada gli infligge danno come a qualsiasi altro Humanoid. Per armi che colpiscono a distanza con le stesse regole lato server, leggi la guida alle armi da fuoco (in inglese).

Errori comuni e soluzioni

Apri la finestra Output (menu Window, poi Output) prima di premere Play. La maggior parte dei problemi con la spada o stampa lì un errore, o nasce da un nome che non corrisponde.

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

SwordClient aspetta il remote che crea SwordService, quindi SwordService non sta funzionando. Controlla che sia uno Script e non un LocalScript, che si trovi direttamente in ServerScriptService, che non sia disattivato e che nell'Output non ci sia un suo errore.

Faccio il fendente, ma nessuno subisce danno

Controlla in ordine: SwordClient è un LocalScript, non uno Script, e si trova direttamente nel Tool Sword; il Tool si chiama esattamente Sword o come indicato in SWORD_NAME; il bersaglio non è a più di 6 stud davanti a te; il bersaglio ha fatto spawn più di 10 secondi fa, quindi il suo ForceField è già sparito; e, se usi Teams, non siete nella stessa squadra con FRIENDLY_FIRE uguale a false.

La spada colpisce i giocatori ma non colpisce mai il mio NPC

Le query spaziali come GetPartBoundsInBox non restituiscono mai una parte con CanQuery disattivato (CanQuery ha effetto solo quando è disattivato anche CanCollide). Riattiva CanQuery sulle parti del corpo dell'NPC e controlla che il suo Humanoid sia figlio diretto del modello dell'NPC.

Il mio personaggio si blocca quando equipaggio la spada

Una parte della spada è ancorata. Seleziona tutte le parti dentro il Tool e togli Anchored.

Alcuni fendenti colpiscono e altri mancano alla stessa distanza

Nella versione con caricamento, un bersaglio uscito dal box durante WINDUP_SECONDS non viene colpito, e il controllo dei muri salta chiunque stia dietro un muro o dietro un altro giocatore. Riduci il caricamento o aumenta HIT_WIDTH se nei playtest i colpi mancati sembrano ingiusti.

Il personaggio impugna la spada per la lama

Ci sono più parti chiamate Handle, e Roblox ha scelto quella sbagliata. Lascia esattamente un Handle, l'impugnatura, e rinomina le altre. Poi regola le proprietà di impugnatura del Tool se l'angolo è ancora sbagliato.

La lama resta ferma o cade quando equipaggio la spada

La lama non è saldata a Handle. Aggiungi un WeldConstraint con Part0 uguale a Handle e Part1 uguale alla lama.

Il danno si vede sul mio schermo, ma la salute dell'altro giocatore non cambia

Il danno viene inflitto da un LocalScript, che cambia solo la tua copia del gioco. Infliggi danno solo in SwordService, come nel passo 2.

Farlo con RoCode

Se non hai voglia di costruire tutto a mano, RoCode può farlo nel place che hai aperto. È un agente IA indipendente per scrivere codice, non di Roblox: descrivi la funzione nella sua chat web, e il suo plugin per Roblox Studio crea il Tool, le parti e gli script nel tuo Explorer, così non devi copiare il codice dalla finestra della chat.

Tu scrivi

Crea una spada: un Tool chiamato Sword in StarterPack con un Handle e una lama saldata a esso, un LocalScript che chiama un RemoteEvent su Activated, e uno Script lato server che controlla un cooldown di 0.6 secondi e infligge 20 di danno a tutti gli Humanoid nel box davanti al giocatore.

RoCode fa
  • Crea il Tool e le sue parti con Create Instance e imposta le loro proprietà con Set Property
  • Scrive SwordService e SwordClient con Create Script e può prima cercare script di combattimento già presenti con Search Scripts
  • Ha l'istruzione di verificare la compilazione di ogni script che scrive con Check Script, che compila il codice in Studio senza eseguirlo (i tipi non li controlla)
  • Mette un punto di annullamento prima e dopo ogni gruppo di modifiche, quindi Ctrl+Z annulla un gruppo alla volta

RoCode non può creare l'animazione del fendente né caricarla: creala nell'Animation Editor e incolla il suo ID. Con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o successivo può controllare un personaggio di prova, ma non clicca nella finestra 3D per fare il fendente, quindi i fendenti li provi tu. La pagina come creare un intero gioco Roblox con RoCode, sistema per sistema mostra dove si inseriscono le armi. Come RoCode si collega a Studio.

Domande frequenti

Perché la mia spada colpisce un giocatore più volte con un solo fendente?

Perché infligge danno da Touched. La pagina di Roblox sul debounce nota che Touched scatta più volte di fila per un solo contatto, e ogni parte del bersaglio può toccare la lama. Questa guida trova i bersagli con una query del box per fendente e tiene una lista, quindi ogni Humanoid perde salute una volta per fendente.

Il danno della spada va in un LocalScript o in uno Script?

In uno Script sul server. Il danno inflitto da un LocalScript cambia solo la copia del gioco di quel giocatore, e tutto ciò che sta sul dispositivo del giocatore un cheater lo può modificare. Il LocalScript deve solo sentire il clic, riprodurre l'animazione e chiamare il RemoteEvent.

Come aggiungo un'animazione del fendente alla spada?

Creala nell'Animation Editor, imposta la priorità Action, pubblicala su Roblox e scrivi il suo asset ID in SWING_ANIMATION_ID come rbxassetid:// seguito dal numero. SwordClient la riproduce tramite l'Animator del personaggio. Le animazioni che il dispositivo di un giocatore avvia sul personaggio di quel giocatore si vedono da tutti.

Perché l'animazione della spada non parte?

Controlla tre cose. La priorità: Action sta sopra Movement, Idle e Core, quindi un fendente con Action viene riprodotto sopra la camminata e l'attesa, mentre una priorità più bassa può essere sovrascritta. Il proprietario: se il gioco appartiene a un gruppo, pubblica l'animazione scegliendo quel gruppo come Creator. L'ID: SWING_ANIMATION_ID deve essere il testo completo rbxassetid:// con il numero della tua animazione, non una stringa vuota.

Qual è la hitbox migliore per una spada su Roblox?

Per la maggior parte dei giochi è una query del box sul server una volta per fendente, come in questa guida: una chiamata a GetPartBoundsInBox, niente da falsificare per il client e tre numeri da regolare. Usa GetPartsInPart con una parte della forma giusta o i raycast lungo la lama solo quando la portata dell'arma è lontana da un box. Il confronto dei quattro metodi.

Come faccio in modo che la spada non colpisca attraverso i muri?

Prima di infliggere danno, lancia un raggio dalla parte radice dell'attaccante alla parte radice del bersaglio, saltando il personaggio dell'attaccante, e conta il colpo solo se la prima cosa che il raggio incontra appartiene al bersaglio. La versione 2 di SwordService lo fa per ogni bersaglio.

Perché il colpo arriva prima che l'animazione del fendente raggiunga il bersaglio?

Il server controlla la hitbox nello stesso istante in cui arriva il clic. Prima aspetta un breve caricamento, per esempio 0.15 secondi con task.delay, poi controlla che l'attaccante sia ancora vivo e impugni la spada, e costruisci il box, come fa la versione 2.

Gli exploiter possono comunque barare con questa spada?

Non possono scegliere chi viene colpito, quanto danno fa un colpo e quanto spesso colpiscono, perché tutte e tre le cose le decide il server; il massimo che guadagnano è 0.1 secondi di margine di rete sul cooldown. Possono però ancora muovere il proprio personaggio, per esempio fino a ridosso di qualcuno, perché ogni dispositivo controlla il movimento del proprio personaggio. Il livello successivo è un controllo del movimento sul server.

Come faccio un sistema di combattimento con le combo?

Tieni sul server un contatore di fendenti per giocatore, azzeralo dopo una breve pausa e scegli danno e animazione in base al contatore. Il controllo del colpo resta lo stesso. La sezione Come estendere tratta anche contraccolpo, uccisioni e parata.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.