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.
TakeDamagedoet 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
Hoe een werkend zwaard in elkaar zit
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:
- De speler klikt, tikt of drukt op de trigger van een gamepad met Sword uitgerust. In het LocalScript gaat
Tool.Activatedaf. - Het LocalScript speelt de zwaaianimatie af als die er is, en vuurt de RemoteEvent
SwordSwingaf. Meer stuurt het niet. - Het serverscript controleert de cooldown, of de speler leeft en of Sword in zijn hand is.
- De server bouwt zijn eigen hitbox voor het personage van de speler en vindt elke Humanoid daarin.
- Elk van die Humanoids verliest één keer health via
TakeDamage.
| Onderdeel | Waar het staat | Wat het doet |
|---|---|---|
Tool Sword | StarterPack | Wat de speler vasthoudt. Roblox kopieert alles uit StarterPack naar de Backpack van de speler elke keer dat zijn personage spawnt. |
Part Handle | In de Tool | De part waaraan het personage het zwaard vasthoudt. Het lemmet is eraan vastgelast. |
LocalScript SwordClient | In de Tool | Hoort de klik, speelt de zwaaianimatie af en vuurt de remote af. |
RemoteEvent SwordSwing | ReplicatedStorage (SwordService maakt hem) | Brengt "ik heb gezwaaid" van het apparaat van de speler naar de server, zonder argumenten. |
Script SwordService | ServerScriptService | Controleert elke zwaai, vindt wie er voor de speler staat en doet schade. De enige plek waar een treffer kan gebeuren. |
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
- 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. - 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. - 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. - Voeg in Blade een WeldConstraint in. Zet in het venster Properties zijn
Part0op Handle enPart1op Blade, zodat het zwaard heel blijft terwijl de speler het draagt. - 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.
- Selecteer de Tool en vink CanBeDropped uit. Staat het aan, dan gooit Backspace het zwaard in Workspace.
- 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.
-- 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.
| Instelling | Waarde hier | Wat 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. |
DAMAGE | 20 | Hoeveel 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_SECONDS | 0.6 | De tijd tussen zwaaien. Zet dezelfde waarde in SwordClient. |
HIT_RANGE, HIT_WIDTH, HIT_HEIGHT | 6, 5, 6 | De hitbox in studs: hoe ver hij voor de speler reikt, hoe breed en hoe hoog hij is. |
FRIENDLY_FIRE | false | Bij false kunnen spelers van hetzelfde team elkaar niet verwonden. Spelers zonder team kunnen elkaar altijd raken, en NPC's kun je altijd raken. |
NETWORK_SLACK | 0.1 | Hoeveel 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 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.
| Stap | Code | Waarom |
|---|---|---|
| De aanvaller overslaan | OverlapParams met Exclude en het personage van de aanvaller | De eigen armen, benen en het zwaard van de aanvaller zitten ook in de box. |
| Het personage vinden | part: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 vinden | model:FindFirstChildOfClass("Humanoid") | Alles met een Humanoid kun je raken: spelers, NPC's en testdummy's. Muren en vloeren worden overgeslagen. |
| Eén keer per Humanoid | tabel alreadyHit | In de box zitten meestal meerdere parts van hetzelfde personage. Zonder de tabel zou elk ervan opnieuw schade doen. |
| Alleen levende doelwitten | target.Health > 0 | Een personage dat al is uitgeschakeld, wordt niet nog eens geraakt. |
| Teams | isTeammate | Met FRIENDLY_FIRE op false worden spelers van hetzelfde team overgeslagen. Een speler van wie de eigenschap Neutral true is, heeft geen team. |
| Schade | target: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.
| Manier | Hoe het werkt | Wie beslist | Precisie | Waar het het best voor is |
|---|---|---|---|---|
Touched op het lemmet | Schade elke keer dat een part van het lemmet een personage aanraakt | Het apparaat van de aanvaller, dat zijn personage en zwaard bezit | Volgt het lemmet, maar gaat meerdere keren per aanraking af | Voor 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 zwaai | De server | Een vaste box, niet het pad van het lemmet. Meshes tellen via bounding boxes, dus iets ruim | De meeste games: simpel, goedkoop en niets te vervalsen |
GetPartsInPart op een hitboxpart | Een serverquery met een part in de vorm van de boog van het lemmet, tijdens de zwaai | De server | Precieze 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 zijn | Grote wapens met een ongewone vorm, zoals de boog van een zeis |
| Raycasts langs het lemmet | Elk frame van de zwaai worden korte stralen geschoten vanaf punten op het lemmet naar waar die in het vorige frame waren | De kant die ze schiet. Op de server heb je een serverbeeld nodig van waar het lemmet is | Volgt de animatie op de voet | Games 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.
| Wapen | DAMAGE | COOLDOWN_SECONDS | HIT_RANGE | HIT_WIDTH | Treffers (tijd) | Schade per seconde |
|---|---|---|---|---|---|---|
| Dolk | 12 | 0.35 | 4 | 4 | 9 (2.8 s) | ongeveer 34 |
| Zwaard (deze handleiding) | 20 | 0.6 | 6 | 5 | 5 (2.4 s) | ongeveer 33 |
| Tweehandig zwaard | 35 | 1.1 | 7 | 7 | 3 (2.2 s) | ongeveer 32 |
| Speer | 18 | 0.8 | 9 | 3 | 6 (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 (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.delaystrikenaWINDUP_SECONDS.strikecontroleert 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
hasClearLineeen 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:
- 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.
- 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.
- 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.
- 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.
- Kopieer de asset-ID van de animatie uit de Toolbox en zet in SwordClient
SWING_ANIMATION_IDop"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.
| Tutorial | Probleem | Deze handleiding |
|---|---|---|
Doet schade in het Touched-event van het lemmet | Het 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 LocalScript | Een 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 cooldown | Roblox 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:LoadAnimation | Verouderd, in plaats daarvan gebruik je Animator:LoadAnimation. | Laadt de zwaai via de Animator. |
Zoekt doelwitten met Region3 en FindPartsInRegion3 | Verouderd. Roblox raadt in nieuwe projecten GetPartBoundsInBox met OverlapParams aan. | Gebruikt GetPartBoundsInBox. |
Zet een serverscript (Script) in de Tool dat naar Activated luistert | Het 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.
| De cheater probeert | Resultaat | Waarom |
|---|---|---|
SwordSwing zo snel afvuren als zijn code kan, of een autoclicker gebruiken | Er telt hoogstens één zwaai per 0.5 seconde | De 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 remote | Genegeerd | onSwing 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 halen | Geen effect op de server | SwordService bewaart zijn instellingen in ServerScriptService, dat nooit naar spelers wordt gestuurd. |
| Slaan terwijl hij dood is of zonder zwaard in de hand | Genegeerd | SwordService 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 map | Er gebeurt niets | De 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 slaan | Mogelijk | Elk 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 slaan | Mogelijk binnen de box van 6 studs | De boxquery uit stap 2 zoekt niet naar muren. Versie 2 voegt een muurcontrole toe. |
| Elke animatie afspelen of geen | Geen effect op treffers | Treffers 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
- 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.
- 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.
- Klik zo snel als je kunt. Alleen één zwaai per 0.6 seconde doet iets.
- 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.
- 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.
- Heeft je game Teams, zet beide testspelers dan in hetzelfde team. Met
FRIENDLY_FIREop 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.
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.
- 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
- Roblox Creator Docs: In-game tools (in het Engels). een tool in Workspace bouwen, Handle, Weld, Grip, verankeren en waarom de meeste tools een LocalScript, Script en RemoteEvent gebruiken
- Roblox Creator Docs: WorldRoot:GetPartBoundsInBox (in het Engels). boxquery, OverlapParams en de verouderde FindPartsInRegion3
- Roblox Creator Docs: Humanoid:TakeDamage (in het Engels). bescherming door ForceField, healthbalk en herstel van health
- Roblox Creator Docs: Network ownership (in het Engels). de exploit met een zwaard op Touched
- Roblox Creator Docs: Security tactics and cheat mitigation (in het Engels). vertrouw de client nooit
- Roblox Creator Docs: Network ownership, movement validation and physics exploits (in het Engels). wat een client met zijn personage kan doen en bewegingscontroles
- Roblox Creator Docs: Animation Editor (in het Engels). animatieprioriteit en publiceren
- Roblox Creator Docs: Animator:LoadAnimation (in het Engels). welke animaties vanaf de client worden gerepliceerd
- Roblox Creator Docs: Debounce patterns (in het Engels). waarom Touched meerdere keren per aanraking afgaat
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.