Tutorial · Gamesystemen

Hoe maak je een zwaard in Roblox Studio

Een zwaard in Roblox is een Tool met drie taken, verdeeld over twee scripts: het apparaat van de speler merkt de klik op en speelt de zwaai af, en de server beslist wie geraakt is en hoeveel health die verloor. In deze handleiding bouwen we beide scripts, met een cooldown en een hitbox die spelers niet kunnen vervalsen, en laten we zien waar de animatie komt.

Bijgewerkt 20 november 202625 min lezenAuteur:

In het kort

Zet in StarterPack een Tool met de naam Sword en een part met de naam Handle. Een LocalScript in de Tool luistert naar Tool.Activated, speelt een zwaaianimatie af en vuurt een RemoteEvent af zonder argumenten. Een Script in ServerScriptService controleert de cooldown en of de speler leeft en het zwaard vasthoudt, vindt elke Humanoid in een box voor hem met workspace:GetPartBoundsInBox en roept Humanoid:TakeDamage één keer per doelwit aan.

  • Doe geen schade vanuit het Touched-event van het lemmet: het apparaat van de speler bestuurt zijn eigen personage en kan Touched overal vandaan laten afgaan, en juist een zwaard staat als voorbeeld op de pagina van Roblox over network ownership.
  • De client stuurt geen doelwit en geen schade. De server bezit de cooldown, de hitbox en de hoeveelheid schade.
  • TakeDamage doet niets zolang het doelwit een ForceField heeft, bijvoorbeeld de eerste 10 seconden na het spawnen op een SpawnLocation.
  • Gaan treffers door muren heen of landen ze voordat de zwaai het doelwit zichtbaar raakt? Neem de versie van het serverscript met uithaal en muurcontrole.
Op deze pagina
  1. Hoe het werkt
  2. 1. De Tool bouwen
  3. 2. Serverscript
  4. 3. LocalScript
  5. Hitbox
  6. Soorten hitboxes
  7. Uithaal en muurcontrole
  8. Zwaaianimatie
  9. Oudere tutorials
  10. Grenzen van de beveiliging
  11. 4. Testen
  12. Uitbreidingen
  13. Common errors
  14. Met RoCode
  15. Veelgestelde vragen
  16. Bronnen en verder lezen

Hoe een werkend zwaard in elkaar zit

IllustratieZwaaien met minstens 0.6 seconde ertussen halen elk 20 health weg, een klik binnen de cooldown doet niets, en de vijfde treffer schakelt de rig uit.

Een zwaard dat in een echte game werkt, is verdeeld tussen het apparaat van de speler en de server. Op de pagina van Roblox over tools staat dat invoer voor tools in een LocalScript hoort, omdat alleen het apparaat van de speler weet wanneer invoer plaatsvindt, en dat de meeste tools een LocalScript, een serverscript (Script) en een RemoteEvent daartussen nodig hebben. Deze handleiding gebruikt precies die verdeling. Eén zwaai ziet er zo uit:

  1. De speler klikt, tikt of drukt op de trigger van een gamepad met Sword uitgerust. In het LocalScript gaat Tool.Activated af.
  2. Het LocalScript speelt de zwaaianimatie af als die er is, en vuurt de RemoteEvent SwordSwing af. Meer stuurt het niet.
  3. Het serverscript controleert de cooldown, of de speler leeft en of Sword in zijn hand is.
  4. De server bouwt zijn eigen hitbox voor het personage van de speler en vindt elke Humanoid daarin.
  5. Elk van die Humanoids verliest één keer health via TakeDamage.
Waar het zwaard uit bestaat
OnderdeelWaar het staatWat het doet
Tool SwordStarterPackWat de speler vasthoudt. Roblox kopieert alles uit StarterPack naar de Backpack van de speler elke keer dat zijn personage spawnt.
Part HandleIn de ToolDe part waaraan het personage het zwaard vasthoudt. Het lemmet is eraan vastgelast.
LocalScript SwordClientIn de ToolHoort de klik, speelt de zwaaianimatie af en vuurt de remote af.
RemoteEvent SwordSwingReplicatedStorage (SwordService maakt hem)Brengt "ik heb gezwaaid" van het apparaat van de speler naar de server, zonder argumenten.
Script SwordServiceServerScriptServiceControleert elke zwaai, vindt wie er voor de speler staat en doet schade. De enige plek waar een treffer kan gebeuren.
De Explorer als het zwaard klaar is. SwordService voegt een RemoteEvent met de naam SwordSwing toe aan ReplicatedStorage als de game draait.
ServerScriptService
  SwordService Script new
StarterPack
  Sword Tool new
    Handle Part new
    Blade Part new
      WeldConstraint WeldConstraint new
    SwordClient LocalScript new

Stap 1: bouw de Tool van het zwaard

  1. Beweeg in de Explorer de cursor over Workspace, klik op de knop + en voeg een Tool in. Hernoem hem naar Sword. Het serverscript zoekt precies deze naam. Je bouwt het zwaard in Workspace, zoals de pagina van Roblox over tools aanraadt, omdat je daar de parts ziet en ze kunt verplaatsen en schalen. De laatste stap zet het in StarterPack.
  2. Voeg in de Tool een Part in en noem het Handle. Dat is het gevest waaraan het personage het zwaard vasthoudt. Het moet een direct kind van de Tool zijn en de enige part met die naam: met twee Handles kiest Roblox er willekeurig een, en kan het personage het zwaard bij het lemmet vasthouden.
  3. Voeg een tweede Part in de Tool in, noem het Blade, geef het een vorm en zet het zo dat het boven uit de Handle steekt.
  4. Voeg in Blade een WeldConstraint in. Zet in het venster Properties zijn Part0 op Handle en Part1 op Blade, zodat het zwaard heel blijft terwijl de speler het draagt.
  5. Selecteer beide parts en controleer dat Anchored uit staat. Een verankerde part in een tool zet het personage vast op zijn plek als het de tool uitrust. Zet bij beide ook CanCollide uit, zodat het lemmet bij een zwaai niet tegen spelers en muren botst.
  6. Selecteer de Tool en vink CanBeDropped uit. Staat het aan, dan gooit Backspace het zwaard in Workspace.
  7. Sleep de klare Sword van Workspace naar StarterPack. Een Tool die in Workspace blijft, is een item dat één speler oppakt, geen zwaard dat vanaf het begin in de Backpack van iedereen zit.

Een zwaard van één MeshPart werkt ook: noem die MeshPart Handle en sla de Weld over. Houdt het personage het zwaard bij het testen onder een vreemde hoek vast, selecteer dan de Tool en pas de grip-eigenschappen aan (GripPos, GripForward, GripRight en GripUp) in het venster Properties.

Stap 2: voeg het serverscript toe

Beweeg de cursor over ServerScriptService, voeg een Script in met de naam SwordService en plak de code hieronder erin. Dit is de enige plek waar een zwaardtreffer kan gebeuren. De instellingen bovenaan zijn de regels die je juist hoort aan te passen.

Script in ServerScriptService met de naam SwordService
-- Script in ServerScriptService met de naam SwordService.
-- De enige plek waar een zwaardtreffer kan gebeuren: controleert de zwaai, vindt doelwitten voor
-- de aanvaller met een eigen hitbox en doet schade.

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

-- Instellingen
local SWORD_NAME = "Sword" -- naam van de Tool in StarterPack
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- houd dezelfde waarde in SwordClient
local HIT_RANGE = 6 -- studs voor de aanvaller
local HIT_WIDTH = 5
local HIT_HEIGHT = 6
local FRIENDLY_FIRE = false -- false: spelers van hetzelfde team kunnen elkaar niet verwonden
-- Zwaaien die precies COOLDOWN_SECONDS na elkaar worden verstuurd, kunnen na netwerkvertraging
-- iets dichter bij elkaar aankomen, dus de server geeft zoveel speling en weigert geen echte zwaai
local NETWORK_SLACK = 0.1

-- De remote die het LocalScript van het zwaard afvuurt. Hij draagt geen argumenten: wie geraakt
-- wordt, beslist de server, dus de client heeft niets te vervalsen.
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
	-- Neutrale spelers (zonder team) kunnen elkaar altijd raken
	return not attacker.Neutral and not target.Neutral and attacker.Team == target.Team
end

local function onSwing(player: Player)
	-- 1. Eén zwaai per cooldown, hoe vaak de remote ook wordt afgevuurd
	local now = os.clock()
	local last = lastSwing[player]
	if last and now - last < COOLDOWN_SECONDS - NETWORK_SLACK then
		return
	end

	-- 2. De aanvaller moet leven en het zwaard vasthouden
	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. De eigen hitbox van de server: een box voor de rootpart van de aanvaller
	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. Elke Humanoid in de box krijgt één keer schade, ook als er meerdere parts van hem in zitten
	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) -- doet niets zolang het doelwit een ForceField heeft
			end
		end
	end
end

swingEvent.OnServerEvent:Connect(onSwing)

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

SwordService maakt de RemoteEvent SwordSwing zelf bij het starten van de game, dus je hoeft niets met de hand in ReplicatedStorage te zetten. Heb je al een RemoteEvent met die naam gemaakt, verwijder hem dan: het LocalScript zou de jouwe kunnen vinden, en daar luistert op de server niemand naar.

Instellingen bovenaan SwordService
InstellingWaarde hierWat het verandert
SWORD_NAME"Sword"De naam van de Tool die de server in de hand van de speler verwacht. Verander hem als je Tool anders heet.
DAMAGE20Hoeveel health elke treffer weghaalt. Een Humanoid begint met 100 health, dus vijf treffers schakelen een testrig uit. Personages van spelers herstellen standaard elke seconde 1% van MaxHealth, dus een speler die op maximale snelheid wordt geraakt, overleeft de vijfde treffer, en er is een zesde nodig.
COOLDOWN_SECONDS0.6De tijd tussen zwaaien. Zet dezelfde waarde in SwordClient.
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT6, 5, 6De hitbox in studs: hoe ver hij voor de speler reikt, hoe breed en hoe hoog hij is.
FRIENDLY_FIREfalseBij false kunnen spelers van hetzelfde team elkaar niet verwonden. Spelers zonder team kunnen elkaar altijd raken, en NPC's kun je altijd raken.
NETWORK_SLACK0.1Hoeveel eerder dan de cooldown de server een zwaai nog accepteert. Twee klikken met 0.6 seconde ertussen kunnen na netwerkvertraging iets dichter bij elkaar aankomen, en zonder deze speling zou de server een echte zwaai weigeren die de speler al heeft gezien.

Stap 3: voeg een LocalScript toe aan de Tool

Voeg in de Tool Sword een LocalScript in, noem het SwordClient en plak deze code erin:

LocalScript in Tool Sword in StarterPack met de naam SwordClient
-- LocalScript in de Tool Sword met de naam SwordClient.
-- Tool.Activated gaat af op het apparaat van de speler, dus dit script luistert naar de klik,
-- tik of trigger, speelt de zwaaianimatie af en vraagt de server om een zwaai.

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 -- dezelfde waarde als in SwordService
local SWING_ANIMATION_ID = "" -- optioneel: "rbxassetid://" en daarna de id van je animatie

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

-- De animatie één keer per personage laden. Animaties die op je eigen
-- personage vanaf je eigen apparaat worden gestart, zijn zichtbaar voor alle spelers.
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 -- de server controleert dit ook; deze controle hier bespaart overbodige verzoeken
	end
	lastSwing = now
	if swingTrack then
		swingTrack:Play()
	end
	swingEvent:FireServer()
end)

Laat SWING_ANIMATION_ID voorlopig leeg. Het zwaard werkt ook zonder animatie, want de treffer beslist in elk geval de server. Hoe je hem invult, staat in het onderdeel Voeg een zwaaianimatie toe.

Activated gaat af bij een muisklik, een tik op een telefoon en een trigger op een gamepad, dus hetzelfde script werkt op elk apparaat. Roblox kopieert de Tool en het LocalScript erin naar de Backpack van elke speler als zijn personage spawnt, dus elke speler draait zijn eigen kopie.

Het LocalScript houdt een eigen cooldown alleen bij om geen verzoeken te sturen die de server toch negeert. Het is geen beveiligingscontrole: een cheater kan het verwijderen, aanpassen of SwordSwing vanuit zijn eigen code afvuren. De handleiding over RemoteEvents legt uit waarom elke remote op de server moet worden gecontroleerd, en Script vs LocalScript vs ModuleScript (in het Engels) laat zien wat een LocalScript wel en niet kan veranderen.

Hoe de server beslist wie geraakt is

Als SwordSwing binnenkomt, vraagt SwordService niets aan de client. Het bouwt een box voor het personage van de aanvaller op de plek waar de server hem ziet, en vraagt de engine welke parts erin zitten met workspace:GetPartBoundsInBox. Die methode vervangt de oudere FindPartsInRegion3, die Roblox als verouderd markeert.

Het midden van de box ligt 3 studs voor de rootpart van de aanvaller. Dat is de verschuiving CFrame.new(0, 0, -HIT_RANGE / 2): een CFrame kijkt langs zijn negatieve Z-as, dat is zijn LookVector. De box loopt dus vanaf het midden van het personage 6 studs naar voren, en is 5 studs breed en 6 hoog. De query vergelijkt de bounding box van elke part, een snelle doosvormige benadering van zijn volume, dus ronde parts en meshes tellen iets groter dan ze eruitzien. Voor een zwaard is die kleine marge handig.

Wat SwordService doet met de parts in de box
StapCodeWaarom
De aanvaller overslaanOverlapParams met Exclude en het personage van de aanvallerDe eigen armen, benen en het zwaard van de aanvaller zitten ook in de box.
Het personage vindenpart:FindFirstAncestorOfClass("Model")Een part in de box kan een ledemaat zijn, een hoed of een tool in de hand. FindFirstAncestorOfClass vergelijkt de exacte klassenaam, dus gaat voorbij aan een hoed (klasse Accessory) en een tool in de hand (klasse Tool, ook al is een Tool een soort Model) en stopt bij het model van het personage.
De Humanoid vindenmodel:FindFirstChildOfClass("Humanoid")Alles met een Humanoid kun je raken: spelers, NPC's en testdummy's. Muren en vloeren worden overgeslagen.
Eén keer per Humanoidtabel alreadyHitIn de box zitten meestal meerdere parts van hetzelfde personage. Zonder de tabel zou elk ervan opnieuw schade doen.
Alleen levende doelwittentarget.Health > 0Een personage dat al is uitgeschakeld, wordt niet nog eens geraakt.
TeamsisTeammateMet FRIENDLY_FIRE op false worden spelers van hetzelfde team overgeslagen. Een speler van wie de eigenschap Neutral true is, heeft geen team.
Schadetarget:TakeDamage(DAMAGE)Verlaagt Health, tenzij een ForceField het doelwit beschermt.

De tabel alreadyHit wordt bij elke zwaai opnieuw gemaakt, dus dezelfde speler kan bij de volgende zwaai opnieuw worden geraakt als de cooldown voorbij is. Dat is precies de regel "één keer per doelwit per zwaai", waar zwaarden op Touched steeds moeite mee hebben.

Het script gebruikt TakeDamage en geen toewijzing aan Health. In de referentie van Roblox staat dat TakeDamage een Humanoid niet raakt zolang een ForceField hem beschermt, terwijl Health direct toewijzen het ForceField negeert. Een speler die op een SpawnLocation spawnt, krijgt standaard 10 seconden een ForceField (Duration van de SpawnLocation), dus nieuwkomers kun je niet raken op het moment dat ze verschijnen.

Vier manieren om een zwaardhitbox te maken: een vergelijking

Zwaardtutorials verschillen vooral op één punt: hoe weet je wat het lemmet heeft geraakt. Er zijn vier gangbare antwoorden. Ze verschillen in hoe precies ze het lemmet volgen, hoeveel werk ze de server kosten en of een cheater het resultaat kan vervalsen.

Manieren om een zwaardhitbox te maken. "Wie beslist" is de kant waarvan het antwoord telt
ManierHoe het werktWie beslistPrecisieWaar het het best voor is
Touched op het lemmetSchade elke keer dat een part van het lemmet een personage aanraaktHet apparaat van de aanvaller, dat zijn personage en zwaard bezitVolgt het lemmet, maar gaat meerdere keren per aanraking afVoor niets in een game met andere spelers: het apparaat van de aanvaller kan het overal vandaan laten afgaan
Box voor de speler (deze handleiding)Eén query GetPartBoundsInBox op de server per zwaaiDe serverEen vaste box, niet het pad van het lemmet. Meshes tellen via bounding boxes, dus iets ruimDe meeste games: simpel, goedkoop en niets te vervalsen
GetPartsInPart op een hitboxpartEen serverquery met een part in de vorm van de boog van het lemmet, tijdens de zwaaiDe serverPrecieze vormen: in de documentatie van Roblox staat dat het een volledige geometrische controle doet, en box- of bolqueries worden aangeraden als minder precisie volstaat, omdat die goedkoper zijnGrote wapens met een ongewone vorm, zoals de boog van een zeis
Raycasts langs het lemmetElk frame van de zwaai worden korte stralen geschoten vanaf punten op het lemmet naar waar die in het vorige frame warenDe kant die ze schiet. Op de server heb je een serverbeeld nodig van waar het lemmet isVolgt de animatie op de voetGames waar het precieze pad van de zwaai telt. Zo werken de hitboxmodules uit de community

De box is de juiste eerste keuze. Het is één query per zwaai, hij hangt nooit af van een animatie die een cheater zou kunnen veranderen, en je stelt hem makkelijk in met drie getallen. Stap over op een part met de juiste vorm of stralen langs het lemmet als spelers klagen dat treffers niet goed voelen bij een wapen waarvan het bereik ver van een box afwijkt, en houd dezelfde regel aan: de server doet de query en de schade.

Zwaardpresets: van dolk tot tweehander

Dezelfde SwordService maakt met vijf instellingen heel verschillende wapens. De tabel is een startpunt, berekend voor een dummy uit de Rig Generator met 100 Health. "Tijd tot uitschakelen" telt vanaf de eerste treffer, als elke zwaai raakt zodra de cooldown het toelaat.

Instellingen van SwordService voor gangbare slagwapens, met het aantal treffers en de tijd tot het uitschakelen van een dummy met 100 Health. Berekend, niet gemeten
WapenDAMAGECOOLDOWN_SECONDSHIT_RANGEHIT_WIDTHTreffers (tijd)Schade per seconde
Dolk120.35449 (2.8 s)ongeveer 34
Zwaard (deze handleiding)200.6655 (2.4 s)ongeveer 33
Tweehandig zwaard351.1773 (2.2 s)ongeveer 32
Speer180.8936 (4 s)ongeveer 23
  • Spelers genezen, dummy's niet. Personages van spelers herstellen standaard elke seconde 1% van MaxHealth. Bij precies 100 schade in 5 treffers overleeft een speler die op maximale snelheid wordt geraakt de vijfde treffer, en er is een zesde nodig. Houd marge, bijvoorbeeld 21 schade in plaats van 20, als het precieze aantal treffers belangrijk is.
  • Schaal NETWORK_SLACK mee met de cooldown. De 0.1 seconde uit de handleiding is een zesde van 0.6. Laat je 0.1 staan bij een dolk met een cooldown van 0.35 seconde, dan kan een cheater elke 0.25 seconde slaan, 40% sneller. Neem ongeveer een zesde van COOLDOWN_SECONDS: 0.06 voor de dolk.
  • Houd SwordClient gelijk. Zet daar dezelfde COOLDOWN_SECONDS, anders stuurt de client zwaaien die de server negeert.

Versie 2: uithaal en geen treffers door muren

Als het basiszwaard werkt, komen er twee klachten. De treffer landt op hetzelfde moment dat de speler klikte, voordat de zwaaianimatie het doelwit bereikt, en een zwaai kan iemand aan de andere kant van een dunne muur raken, omdat de box geen muren ziet. Deze versie van SwordService lost beide op. Ze vervangt het script uit stap 2: dezelfde naam, dezelfde remote, dezelfde instellingen, dus SwordClient hoeft niet te veranderen.

Script in ServerScriptService met de naam SwordService
-- Script in ServerScriptService met de naam SwordService (versie met uithaal en muurcontrole).
-- Vervangt het script uit stap 2: dezelfde instellingen en remote plus twee regels. De treffer landt
-- WINDUP_SECONDS na de klik, als de zwaai het doelwit bereikt, en raakt niemand
-- door een muur heen.

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

-- Instellingen
local SWORD_NAME = "Sword"
local DAMAGE = 20
local COOLDOWN_SECONDS = 0.6 -- houd dezelfde waarde in SwordClient
local WINDUP_SECONDS = 0.15 -- tijd van klik tot treffer; stem af op je zwaaianimatie
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

-- Geeft het personage en de rootpart van de aanvaller terug, zolang hij leeft en het zwaard vasthoudt
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 als er tussen de aanvaller en het doelwit niets zit behalve het doelwit zelf
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)
	-- Opnieuw controleren na de uithaal: de aanvaller kan zijn doodgegaan of het zwaard hebben weggestopt
	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)

Verwijder eerst SwordService uit stap 2, anders maken beide scripts een remote SwordSwing. Zet WINDUP_SECONDS op het moment in je zwaaianimatie waarop het lemmet voor het personage langs gaat; voor een snelle zwaai past 0.15.

  • Uithaal. De cooldown en de controles "leeft en houdt het zwaard vast" gebeuren als de klik binnenkomt, daarna start task.delay strike na WINDUP_SECONDS. strike controleert de aanvaller opnieuw, omdat hij in die tijd kan zijn doodgegaan of het zwaard kan hebben weggestopt, en bouwt pas daarna de box. Een doelwit dat tijdens de uithaal buiten bereik is gegaan, wordt niet geraakt, en dat is precies wat spelers verwachten als ze de zwaai zien.
  • Muurcontrole. Voor elk doelwit in de box schiet hasClearLine een straal van de rootpart van de aanvaller naar de rootpart van het doelwit, waarbij het eigen personage van de aanvaller wordt overgeslagen. Als het eerste wat hij raakt van het doelwit is, of als hij niets raakt, telt de treffer. Een muur, een deur of een andere speler ertussen blokkeert hem.
  • Wat het kost. Eén extra straal per doelwit per zwaai, wat weinig is vergeleken met de boxquery zelf.

De uithaal maakt het zwaard ook eerlijker tegen cheaters die slaan op hetzelfde moment dat ze naar iemand teleporteren: de server zoekt een ogenblik later naar doelwitten, op de plek waar hij de personages op dat moment ziet. De teleport zelf stopt dat niet; daarvoor heb je een bewegingscontrole nodig, beschreven in het onderdeel Wat een exploiter wel en niet kan.

Voeg een zwaaianimatie toe (optioneel)

SwordClient speelt al een animatie af zodra je hem een ID geeft. De animatie maak je één keer, in de Animation Editor in Studio:

  1. Voeg een rig in om te animeren. Klik op het tabblad Avatar of Home op Character om de Rig Generator te openen, en kies een rig die past bij de avatars van je game, bijvoorbeeld R15 en daarna Block Avatar.
  2. Klik op het tabblad Avatar op Clip Editor om de Animation Editor te openen, selecteer de rig en zet poses neer voor een korte zwaai met de rechterarm.
  3. Zet de prioriteit op Action: klik op de knop … in de afspeelknoppen van de editor, beweeg de cursor over Set Animation Priority en kies Action. Action staat boven Movement, Idle en Core, dus de zwaai speelt over de loop- en staananimaties heen in plaats van ervan te verliezen.
  4. Kies in hetzelfde menu … voor Publish to Roblox. Is je game van een groep, kies die groep dan in het veld Creator voordat je verstuurt.
  5. Kopieer de asset-ID van de animatie uit de Toolbox en zet in SwordClient SWING_ANIMATION_ID op "rbxassetid://" met daarachter dat getal.

SwordClient laadt de zwaai via de Animator van het personage, niet via de oudere Humanoid:LoadAnimation, die Roblox als verouderd markeert. In de referentie van Roblox over de Animator staat dat animaties die het apparaat van een speler op het eigen personage van die speler start, naar de server en naar alle andere spelers worden gerepliceerd, dus een LocalScript kan de zwaai afspelen en iedereen ziet hem. Daar staat ook dat de Animator op de server moet worden gemaakt, dus maak hem nooit in een LocalScript. Bij personages van spelers zit hij meestal in de Humanoid, en daar zoekt het eigen animatievoorbeeld van Roblox hem ook.

De animatie is alleen voor het uiterlijk. Treffers hangen er niet van af, dus een trage, ontbrekende of aangepaste animatie verandert nooit wie er geraakt wordt.

Hoe je een animatie afspeelt bij een toetsdruk, in een lus of op een NPC, lees je in de handleiding over animatiescripts.

Waar oudere zwaardtutorials de mist in gaan

Vergelijk je deze handleiding met een video of een forumpost, dan zijn dit de belangrijke verschillen en de reden waarom elke aanpak een probleem geeft.

Veelgebruikte aanpakken in zwaardtutorials en wat deze handleiding in plaats daarvan doet
TutorialProbleemDeze handleiding
Doet schade in het Touched-event van het lemmetHet apparaat van de aanvaller kan Touched op zijn zwaard overal vandaan laten afgaan (pagina van Roblox over network ownership), en Touched gaat meerdere keren achter elkaar af bij één aanraking (pagina van Roblox over debounce).De server vindt de doelwitten met een eigen box, één keer per Humanoid per zwaai.
Verlaagt Health in een LocalScriptEen wijziging die een LocalScript aan het personage van een ander doet, blijft op dat ene apparaat.Alle schade gebeurt in SwordService.
Gebruikt wait(0.5) voor de cooldownRoblox markeert de globale wait() als verouderd, in plaats daarvan gebruik je task.wait(), en een cooldown die alleen op de client bestaat, houdt niemand tegen.Vergelijkt de tijd van os.clock() op de server. Er wacht niets.
Speelt de zwaai af via Humanoid:LoadAnimationVerouderd, in plaats daarvan gebruik je Animator:LoadAnimation.Laadt de zwaai via de Animator.
Zoekt doelwitten met Region3 en FindPartsInRegion3Verouderd. Roblox raadt in nieuwe projecten GetPartBoundsInBox met OverlapParams aan.Gebruikt GetPartBoundsInBox.
Zet een serverscript (Script) in de Tool dat naar Activated luistertHet zwaard van elke speler draait zijn eigen kopie van de servercode, en zulke scripts doen vaak schade in Touched (de eerste rij). Met de standaardinstellingen draait een Script alleen in Workspace of ServerScriptService, dus een Script in een Tool start pas als het zwaard voor het eerst wordt uitgerust. De pagina van Roblox over tools beschrijft de meeste tools als een LocalScript voor de invoer, een serverscript voor het effect en een RemoteEvent daartussen.Eén SwordService in ServerScriptService bedient alle zwaarden in de game.

Wat een exploiter wel en niet kan

Ga ervan uit dat een cheater alles op zijn eigen apparaat bestuurt. Hij kan je LocalScripts lezen en aanpassen, en in de beveiligingshandleiding van Roblox staat dat hij RemoteEvents met elke frequentie en met willekeurige argumenten kan afvuren. Dit is wat dat betekent voor dit zwaard.

Wat een cheater kan proberen en wat SwordService ermee doet
De cheater probeertResultaatWaarom
SwordSwing zo snel afvuren als zijn code kan, of een autoclicker gebruikenEr telt hoogstens één zwaai per 0.5 secondeDe servercooldown is 0.6 seconde min 0.1 seconde netwerkspeling. Die speling is het maximum dat de cheater wint.
Een doelwit, een schadegetal of een positie meesturen met de remoteGenegeerdonSwing leest alleen de speler die Roblox zelf invult. Al het andere dat met de remote wordt meegestuurd, wordt nooit gelezen.
SwordClient aanpassen, bijvoorbeeld de cooldown eruit halenGeen effect op de serverSwordService bewaart zijn instellingen in ServerScriptService, dat nooit naar spelers wordt gestuurd.
Slaan terwijl hij dood is of zonder zwaard in de handGenegeerdSwordService controleert dat zijn Humanoid leeft en dat een Tool met de naam Sword in zijn personage zit, waar Roblox de tool naartoe verplaatst bij het uitrusten.
Iemand raken vanaf de andere kant van de mapEr gebeurt nietsDe box wordt gebouwd rond het personage van de aanvaller op de plek waar de server hem ziet, en reikt maar 6 studs naar voren.
Naar een speler teleporteren en dan slaanMogelijkElk apparaat bestuurt de beweging van zijn eigen personage, en Roblox noemt teleporteren naar elk punt onder wat een client met zijn personage kan doen. Een bewegingscontrole op de server kan dat opmerken.
Door een dunne muur heen slaanMogelijk binnen de box van 6 studsDe boxquery uit stap 2 zoekt niet naar muren. Versie 2 voegt een muurcontrole toe.
Elke animatie afspelen of geenGeen effect op treffersTreffers hangen nooit af van de animatie. Roblox merkt op dat cheaters willekeurige animaties op hun personage kunnen afspelen.

In twee rijen staat "Mogelijk", en dat is eerlijk. Dit zwaard laat een cheater niet kiezen wie hij raakt, hoe hard en hoe vaak. Het kan hem niet beletten zijn eigen personage te bewegen. In de beveiligingsdocumentatie van Roblox staat dat clients de beweging en fysica van hun personage besturen en dat bewegingscontroles per game moeten worden afgesteld. Voor een competitieve game is de volgende laag een bewegingscontrole op de server (de handleiding over sprinten bouwt er een, die waarschuwt bij grove speedhacks en verre teleports) of de server authority van Roblox, die de documentatie als bèta beschreef toen we op 13 oktober 2026 keken.

Stap 4: test het

  1. Voeg iets toe om op te slaan. Klik op het tabblad Avatar of Home op Character om de Rig Generator te openen, kies een rig (bijvoorbeeld R15, daarna Block Avatar), en hij wordt in Workspace ingevoegd. Zet hem een paar studs van je SpawnLocation af.
  2. Druk op Play, rust Sword uit vanuit de hotbar, loop naar de rig en klik. Na de eerste treffer verschijnt er een healthbalk boven hem, omdat een Humanoid standaard alleen een balk toont als zijn Health lager is dan MaxHealth. Een Humanoid begint met 100 health, dus de vijfde treffer schakelt hem uit.
  3. Klik zo snel als je kunt. Alleen één zwaai per 0.6 seconde doet iets.
  4. Loop ongeveer 8 studs van de rig weg of draai je rug naar hem toe en zwaai. Er gebeurt niets, omdat geen van zijn parts in de box zit.
  5. Test met een echte speler. Kies Server & Clients in de keuzelijst met testmodi, zet 2 clients en druk op Play. Raak de andere speler binnen 10 seconden na zijn spawn: er gebeurt niets door het ForceField bij het spawnen. Daarna haalt elke treffer 20 weg. Standaard herstellen personages van spelers ook elke seconde 1% van MaxHealth, dus tussen gevechten komt hun health langzaam terug.
  6. Heeft je game Teams, zet beide testspelers dan in hetzelfde team. Met FRIENDLY_FIRE op false doen hun zwaaien elkaar niets.

Houd al die tijd het venster Output open (menu Window, daarna Output). Als deze scripts werken, printen ze niets, dus elke rode fout van SwordService of SwordClient is een echt probleem. Zie Veelvoorkomende fouten.

Het zwaard uitbreiden tot een gevechtssysteem

Combo's

Houd op de server een teller van zwaaien per speler bij, naast lastSwing. Was de vorige zwaai kort geleden, tel er 1 bij op; zo niet, begin opnieuw bij 1. Kies daarna de schade op basis van de teller, bijvoorbeeld meer schade bij elke derde treffer, en wis de teller op dezelfde manier bij PlayerRemoving. De client kan zijn eigen telling bijhouden om te kiezen welke animatie hij afspeelt, want de animatie beslist nooit over de treffer. De box en de controles blijven precies hetzelfde.

Knockback

Na TakeDamage kan SwordService het doelwit wegduwen met ApplyImpulse op de RootPart van het doelwit, in de richting van rootPart.CFrame.LookVector van de aanvaller. In de referentie van Roblox staat dat de duw afhangt van de massa van het doelwit en dat een serverscript hem kan aanroepen op een part die de server bezit of op een part die automatisch door een client wordt bezeten. Het apparaat van elke speler simuleert zijn eigen personage, dus test knockback op spelers met Server & Clients, niet alleen op een rig.

Kills tellen voor een leaderboard

Noteer direct voor target:TakeDamage(DAMAGE) wie als laatste raakte, met target:SetAttribute("LastHitBy", player.UserId). Verbind in een serverscript het event Died van de Humanoid van elk personage, lees dat attribuut, vind de aanvaller met Players:GetPlayerByUserId en tel 1 op bij de IntValue Kills in zijn leaderstats. Maak die naast Coins en Wins, zoals in stap 1 van de handleiding over leaderboards, en verander hem op de server, zoals in stap 2.

Blokkeren

Voeg een tweede RemoteEvent toe die de client afvuurt als de blokknop wordt ingedrukt en losgelaten, en laat de server een attribuut Blocking zetten op het personage van die speler, met een eigen limiet op de frequentie. Verlaag of sla in SwordService de schade over als Blocking op het personage van het doelwit staat. Een cheater kiest nog steeds zelf wanneer hij blokkeert, dus maak het blok kort of geef het een cooldown.

Het zwaard verkopen of per ronde uitdelen

StarterPack geeft het zwaard aan elke speler bij elke spawn. Om het in plaats daarvan te verkopen, zet je het in de map ShopItems uit de handleiding over een winkel-GUI. De catalogus van die handleiding verkoopt al een Tool met de naam ClassicSword, dus noem deze Tool ClassicSword en zet SWORD_NAME op hetzelfde, of pas de regel in de catalogus aan. Om het alleen tijdens een ronde uit te delen, neem je het script GiveRoundTool uit de handleiding over een rondesysteem: bewaar Sword in ServerStorage in plaats van StarterPack, en vervang "RoundTool" in dat script door "Sword".

Vijanden om tegen te vechten en afstandswapens

Volg voor een NPC die spelers achtervolgt de handleiding over pathfinding voor NPC's. Het zwaard doet er schade aan zoals aan elke andere Humanoid. Over een wapen dat op afstand raakt met dezelfde serverregels lees je in de handleiding over wapens.

Veelvoorkomende fouten en oplossingen

Open het venster Output (menu Window, daarna Output) voordat je op Play drukt. De meeste problemen met het zwaard printen daar een fout, of komen door een naam die niet klopt.

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

SwordClient wacht op de remote die SwordService maakt, dus SwordService draait niet. Controleer dat het een Script is, geen LocalScript, dat het direct in ServerScriptService staat, niet is uitgeschakeld en dat er geen fout van in Output staat.

Ik zwaai, maar niemand krijgt schade

Controleer op volgorde: SwordClient is een LocalScript, geen Script, en staat direct in de Tool Sword; de Tool heet precies Sword of zoals in SWORD_NAME staat; het doelwit staat niet verder dan 6 studs voor je; het doelwit is meer dan 10 seconden geleden gespawnd, dus zijn ForceField is weg; en als je Teams gebruikt, zitten jullie niet in hetzelfde team met FRIENDLY_FIRE op false.

Het zwaard raakt spelers, maar nooit mijn NPC

Ruimtelijke queries zoals GetPartBoundsInBox geven nooit een part terug waarbij CanQuery uit staat (CanQuery werkt alleen als CanCollide ook uit staat). Zet CanQuery weer aan bij de lichaamsdelen van de NPC en controleer dat zijn Humanoid een direct kind is van het model van de NPC.

Mijn personage zit vast als ik het zwaard uitrust

Een part van het zwaard is verankerd. Selecteer alle parts in de Tool en vink Anchored uit.

Sommige zwaaien raken en andere missen op dezelfde afstand

In de versie met uithaal wordt een doelwit dat binnen WINDUP_SECONDS uit de box is gegaan niet geraakt, en de muurcontrole slaat iedereen over die achter een muur of een andere speler staat. Verkort de uithaal of vergroot HIT_WIDTH als missers in playtests oneerlijk voelen.

Het personage houdt het zwaard bij het lemmet vast

Er is meer dan één part met de naam Handle, en Roblox heeft de verkeerde gekozen. Houd precies één Handle over, het gevest, en hernoem de andere. Pas daarna de grip-eigenschappen van de Tool aan als de hoek nog niet goed is.

Het lemmet blijft staan of valt als ik het zwaard uitrust

Het lemmet is niet aan de Handle vastgelast. Voeg een WeldConstraint toe met Part0 op Handle en Part1 op het lemmet.

De schade is te zien op mijn scherm, maar de health van de andere speler verandert niet

De schade komt uit een LocalScript, dat alleen jouw kopie van de game verandert. Doe schade alleen in SwordService, zoals in stap 2.

Maak het met RoCode

Heb je geen zin om dit allemaal met de hand te bouwen, dan kan RoCode het doen in de place die je open hebt. Het is een onafhankelijke AI-agent die code schrijft, niet van Roblox: je beschrijft een functie in de webchat, en de plugin voor Roblox Studio maakt de Tool, de parts en de scripts in je Explorer, zodat je geen code uit een chatvenster hoeft te kopiëren.

Jij typt

Maak een zwaard: een Tool met de naam Sword in StarterPack met een Handle en een daaraan vastgelast lemmet, een LocalScript dat bij Activated een RemoteEvent afvuurt, en een serverscript (Script) dat een cooldown van 0.6 seconde controleert en 20 schade doet aan elke Humanoid in een box voor de speler.

RoCode doet
  • Maakt de Tool en de parts ervan met Create Instance en zet hun eigenschappen met Set Property
  • Schrijft SwordService en SwordClient met Create Script en kan eerst met Search Scripts naar bestaande gevechtsscripts zoeken
  • Heeft de opdracht om elk geschreven script te laten compileren met Check Script, dat de code in Studio compileert zonder hem te draaien (types controleert het niet)
  • Zet een ongedaan-maakpunt voor en na elke reeks wijzigingen, dus Ctrl+Z draait telkens één reeks terug

RoCode kan geen zwaaianimatie maken of uploaden: maak die in de Animation Editor en plak de ID erin. Met plugin 3.9 of nieuwer kan RoCode een korte playtest starten en de fouten lezen, en met plugin 3.9.11 of nieuwer kan het een testpersonage besturen, maar het klikt niet in het 3D-venster om te zwaaien, dus de zwaaien test je zelf. De pagina hoe je met RoCode een hele Roblox-game maakt, systeem voor systeem laat zien waar wapens passen. Hoe RoCode verbinding maakt met Studio.

Veelgestelde vragen

Waarom raakt mijn zwaard één speler meerdere keren met één zwaai?

Omdat het schade doet vanuit Touched. Op de pagina van Roblox over debounce staat dat Touched meerdere keren achter elkaar afgaat bij één aanraking, en elke part van het doelwit kan het lemmet aanraken. Deze handleiding vindt doelwitten met één boxquery per zwaai en houdt een lijst bij, dus elke Humanoid verliest één keer per zwaai health.

Hoort zwaardschade in een LocalScript of in een Script?

In een Script op de server. Schade vanuit een LocalScript verandert alleen de kopie van de game van die speler, en alles op het apparaat van een speler kan een cheater aanpassen. Het LocalScript moet alleen de klik horen, de animatie afspelen en de RemoteEvent afvuren.

Hoe voeg ik een zwaaianimatie toe aan een zwaard?

Maak hem in de Animation Editor, zet de prioriteit op Action, publiceer hem naar Roblox en zet zijn asset-ID in SWING_ANIMATION_ID als rbxassetid:// met daarachter het getal. SwordClient speelt hem af via de Animator van het personage. Animaties die het apparaat van een speler op het eigen personage van die speler start, zijn voor iedereen zichtbaar.

Waarom speelt mijn zwaardanimatie niet af?

Controleer drie dingen. Prioriteit: Action staat boven Movement, Idle en Core, dus een zwaai met Action speelt over lopen en stilstaan heen, en een lagere prioriteit kan ervan verliezen. Eigenaar: is de game van een groep, publiceer de animatie dan met die groep als Creator. ID: SWING_ANIMATION_ID moet de volledige tekst rbxassetid:// met het getal van je animatie zijn, geen lege string.

Wat is de beste hitbox voor een zwaard in Roblox?

Voor de meeste games een boxquery op de server, één keer per zwaai, zoals in deze handleiding: één aanroep van GetPartBoundsInBox, niets wat de client kan vervalsen, en drie getallen om in te stellen. Gebruik GetPartsInPart met een part van de juiste vorm of raycasts langs het lemmet alleen als het bereik van het wapen ver van een box afwijkt. Vergelijking van de vier manieren.

Hoe zorg ik dat het zwaard niet door muren raakt?

Schiet voor het doen van schade een straal van de rootpart van de aanvaller naar de rootpart van het doelwit, waarbij je het personage van de aanvaller overslaat, en laat de treffer alleen tellen als het eerste wat de straal raakt van het doelwit is. Versie 2 van SwordService doet dit voor elk doelwit.

Waarom landt de treffer voordat de zwaaianimatie het doelwit bereikt?

De server controleert de hitbox op hetzelfde moment dat de klik binnenkomt. Wacht eerst een korte uithaal, bijvoorbeeld 0.15 seconde met task.delay, controleer daarna dat de aanvaller nog leeft en het zwaard vasthoudt, en bouw dan de box, zoals versie 2 doet.

Kunnen exploiters met dit zwaard toch nog cheaten?

Ze kunnen niet kiezen wie er geraakt wordt, hoeveel schade een treffer doet en hoe vaak ze slaan, omdat de server alle drie beslist; het maximum dat ze winnen is 0.1 seconde netwerkspeling op de cooldown. Ze kunnen nog steeds hun personage bewegen, bijvoorbeeld vlak naast iemand, omdat elk apparaat de beweging van zijn eigen personage bestuurt. De volgende laag is een bewegingscontrole op de server.

Hoe maak ik een gevechtssysteem met combo's?

Houd op de server een teller van zwaaien per speler bij, zet hem terug na een korte pauze en kies de schade en animatie op basis van de teller. De treffercontrole blijft hetzelfde. Het onderdeel Uitbreiden behandelt ook knockback, kills tellen en blokkeren.

Bronnen en verder lezen

Hoe de code is gecontroleerd: elk script op deze pagina doorloopt een strikte Luau-typecontrole met de Roblox API-definities (luau-lsp, 20 november 2026). De typecontrole vangt fouten in API-namen en verkeerde types op, maar geen fouten in de gamelogica, dus test alles in Studio voordat je publiceert.

Probeer RoCode in je eigen game.

Elke dag gratis credits, geen creditcard nodig. Installeer de plugin, beschrijf een functie en kijk wat er in Studio verschijnt.