Tutorial · Basis van scripting

RemoteEvent in Roblox: van client naar server en terug

Een LocalScript kan niet veranderen wat andere spelers zien, en een Script op de server kan niet bij het scherm van één speler. Berichten tussen die twee gaan via RemoteEvents. In deze handleiding bouwen we de drie patronen die je het vaakst nodig hebt, een RemoteFunction die een antwoord teruggeeft, en de controles op de server die voorkomen dat een aangepaste client er misbruik van maakt.

Bijgewerkt 20 november 202620 min lezenAuteur:

In het kort

Een RemoteEvent is een object dat meestal in ReplicatedStorage staat en berichten over de grens tussen client en server stuurt. Een LocalScript roept FireServer aan, en de server ontvangt het bericht in OnServerEvent, waarbij de Player die het stuurde als eerste argument is toegevoegd. De server roept FireClient(player, ...) of FireAllClients(...) aan, en LocalScripts ontvangen het bericht in OnClientEvent.

  • Gebruik een RemoteFunction (InvokeServer en OnServerInvoke) alleen als de client een antwoord nodig heeft. Vermijd InvokeClient: een client die een fout krijgt, vertrekt of nooit een waarde teruggeeft, breekt de aanroep op de server.
  • Vertrouw nooit wat de client stuurt. Controleer op de server het type, het bereik en het eigendom van elk argument, de afstand tot de speler en hoe vaak hij de remote aanroept.
  • Functies, metatables en objecten die de andere kant niet ziet, overleven het versturen niet. Een UnreliableRemoteEvent kan berichten kwijtraken of de volgorde veranderen en gooit alle data groter dan 1000 bytes weg.
Op deze pagina
  1. Waarom remotes
  2. Remotes instellen
  3. 1. Client naar server
  4. 2. Server naar client
  5. 3. Server naar iedereen
  6. RemoteFunction
  7. Checklist voor controles
  8. Wat niet kan
  9. Geeft nil terug?
  10. UnreliableRemoteEvent
  11. Volgorde en limieten
  12. Wat kies je
  13. Common errors
  14. Met RoCode
  15. Veelgestelde vragen
  16. Bronnen en verder lezen

Waarom je RemoteEvents nodig hebt

IllustratieElke klik vraagt de server om een part te verven, daarom is de nieuwe kleur op de schermen van beide spelers te zien.

Elke Roblox-game draait als één server plus één client per speler. De server is hier de baas: een nieuw object of een gewijzigde eigenschap bereikt alle spelers alleen als de server het doet. Een wijziging in een LocalScript blijft op één apparaat, op een paar uitzonderingen na, zoals het eigen personage van de speler, waarvan de beweging door zijn client wordt gestuurd. Dus als een klik of toetsaanslag de gedeelde wereld moet veranderen, moet de client het de server vragen, en als de server wil dat het scherm van één speler reageert, moet hij het die client laten weten. Is het verschil tussen Script en LocalScript nieuw voor je, lees dan eerst Script vs LocalScript vs ModuleScript (in het Engels). Is scripting zelf nieuw, begin dan met hoe je scripts schrijft in Roblox Studio.

Om die grens over te steken geeft Roblox je drie objecten:

  • RemoteEvent: een bericht in één richting. De afzender gaat meteen verder.
  • RemoteFunction: een verzoek dat op een antwoord wacht. De aanroepende code staat op pauze tot de andere kant een waarde teruggeeft.
  • UnreliableRemoteEvent: een bericht in één richting dat kwijt kan raken of in de verkeerde volgorde kan aankomen, maar het netwerk minder belast. Geschikt voor data die steeds verandert.
Welke aanroep welk event start
RichtingAfzender roept aanOntvanger verbindt metOntvanger krijgt
Van client naar serverremote:FireServer(...) in een LocalScriptremote.OnServerEvent in een ScriptDe Player die het bericht stuurde, daarna je argumenten
Van server naar één clientremote:FireClient(player, ...) in een Scriptremote.OnClientEvent in een LocalScriptAlleen je argumenten
Van server naar alle clientsremote:FireAllClients(...) in een Scriptremote.OnClientEvent in een LocalScriptAlleen je argumenten
Client vraagt, server antwoordtremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)De Player, daarna je argumenten. De aanroeper krijgt wat de functie teruggaf

Clients kunnen elkaar niet direct berichten sturen. Om iets van één speler aan de anderen door te geven, stuur je het naar de server, controleer je het daar, en laat je de server het doorsturen met FireClient of FireAllClients. Volgens de beveiligingsrichtlijnen van Roblox werkt de server hier als poortwachter, niet als simpel doorgeefluik.

Waar je remotes bewaart

Een remote moet staan waar zowel de server als de clients hem zien. De gebruikelijke plek is ReplicatedStorage; de documentatie van Roblox noemt dat in sommige gevallen ook Workspace of een Tool kan. ServerStorage en ServerScriptService zijn alleen voor de server zichtbaar, dus een LocalScript dat daar op een remote wacht, wacht eeuwig.

  1. Beweeg in de Explorer je muis over ReplicatedStorage, klik op de knop + en voeg een Folder in. Noem de map Remotes.
  2. Beweeg je muis over Remotes, klik op + en voeg een RemoteEvent in. Geef hem een naam die zegt waar hij voor is, bijvoorbeeld PaintRequest.
  3. Herhaal dit voor elke remote. Deze handleiding gebruikt twee RemoteEvents (PaintRequest en Notify) en één RemoteFunction (RedeemCode).
Explorer: alles wat deze handleiding toevoegt, sectie voor sectie
ReplicatedStorage
  Remotes  Folder  new
    PaintRequest  RemoteEvent  new
    Notify  RemoteEvent  new
    RedeemCode  RemoteFunction  new
ServerScriptService
  PaintServer  Script  new
  WelcomeServer  Script  new
  FinishAnnouncer  Script  new
  RedeemServer  Script  new
  RemoteGuard  ModuleScript  new
StarterPlayer
  StarterPlayerScripts
    PaintClient  LocalScript  new
    NotifyClient  LocalScript  new
StarterGui
  CodeGui  ScreenGui  new
    CodeBox  TextBox  new
      RedeemClient  LocalScript  new
Workspace
  Paintable  Folder  new
  FinishLine  Part  new

De scripts in deze handleiding vinden de remotes met WaitForChild. Dat geeft meteen resultaat als de remote er al is, en wacht als hij er nog niet is, bijvoorbeeld als een serverscript de remotes tijdens het spelen aanmaakt. Maak een aparte remote voor elk soort verzoek: dan controleert elke handler op de server één vorm van argumenten, en dat goed doen is veel makkelijker dan met één remote voor alles.

Patroon 1: van client naar server, met controle op de server

De meest voorkomende taak: een speler doet iets op zijn scherm, en de server beslist wat er gebeurt. Hier drukt de speler op Q om een van vier kleuren te kiezen, en klikt of tikt op een part om hem te verven. Iedereen ziet de nieuwe kleur, omdat de server verft.

De client stuurt twee dingen: welke part en het nummer van de kleur. De kleur zelf stuurt hij nooit, en in andere games moet hij net zo min een prijs, beloning of hoeveelheid schade sturen. Een aangepaste client kan alles sturen, dus de echte data (hier het palet) bewaart de server, en de argumenten behandelt hij als een verzoek dat gecontroleerd moet worden.

  1. Voeg in Workspace een Folder in met de naam Paintable en zet er een paar geankerde Parts in.
  2. Controleer dat ReplicatedStorage.Remotes een RemoteEvent met de naam PaintRequest bevat.
  3. Voeg een Script met de naam PaintServer in ServerScriptService in en een LocalScript met de naam PaintClient in StarterPlayer, StarterPlayerScripts, met de code hieronder.
Script in ServerScriptService met de naam PaintServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local remotes = ReplicatedStorage:WaitForChild("Remotes")
local paintRequest = remotes:WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")

-- Kleuren zijn van de server. De client stuurt alleen een nummer dat er een van kiest.
local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local MAX_DISTANCE = 30 -- studs tussen personage en part
local COOLDOWN_SECONDS = 0.25

local lastPaint: { [Player]: number } = {}

-- De eerste parameter is altijd de speler die de remote aanriep. Roblox vult hem in,
-- dus die kun je vertrouwen. Alles daarna komt van de client, en dat kun je niet vertrouwen.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Type: een echte part, geen table die zich voordoet als part
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Bereik: een geheel getal van 1 tot 4. NaN en oneindig vallen hier ook af.
	if type(colourIndex) ~= "number" or not math.isfinite(colourIndex) then
		return
	end
	if colourIndex % 1 ~= 0 or colourIndex < 1 or colourIndex > #PALETTE then
		return
	end

	-- 3. Toegestaan doel: alleen parts in de map Paintable, niets anders in de game
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Afstand: het personage van de speler moet dicht bij de part zijn
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if not (root and root:IsA("BasePart")) then
		return
	end
	if (root.Position - part.Position).Magnitude > MAX_DISTANCE then
		return
	end

	-- 5. Frequentielimiet: één keer verven per speler per kwart seconde
	local now = os.clock()
	local last = lastPaint[player]
	if last and now - last < COOLDOWN_SECONDS then
		return
	end
	lastPaint[player] = now

	part.Color = PALETTE[colourIndex]
end)

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

Elke controle die faalt doet gewoon return. Het heeft geen zin om een valsspelende client uit te leggen waarom hij geweigerd wordt.

LocalScript in StarterPlayerScripts met de naam PaintClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")

local remotes = ReplicatedStorage:WaitForChild("Remotes")
local paintRequest = remotes:WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")

local COLOUR_COUNT = 4 -- de echte kleuren bewaart de server
local selectedColour = 1

-- De ray kan alleen parts in de map Paintable raken
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- de toets of klik ging naar de chat of naar een knop
	end

	if input.KeyCode == Enum.KeyCode.Q then
		selectedColour = selectedColour % COLOUR_COUNT + 1
		return
	end

	local isClick = input.UserInputType == Enum.UserInputType.MouseButton1
	local isTap = input.UserInputType == Enum.UserInputType.Touch
	if isClick or isTap then
		local camera = workspace.CurrentCamera
		local ray = camera:ScreenPointToRay(input.Position.X, input.Position.Y)
		local result = workspace:Raycast(ray.Origin, ray.Direction * 500, rayParams)
		if result then
			-- We vragen, we bevelen niet: of er geverfd wordt, beslist de server
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed is true als de engine deze invoer al heeft verwerkt, meestal in de interface: een klik op een knop of toetsen die in een tekstveld zoals de chatbalk worden getypt. Dankzij deze controle verandert de letter Q in een chatbericht de kleur niet.

Patroon 2: van server naar één client

De server stuurt een bericht naar één speler met FireClient. Het eerste argument is de Player voor wie het bedoeld is, en de handler op de client krijgt alleen de argumenten daarna. Gebruik dit voor alles wat persoonlijk is: een melding, een venster met een beloning, een geluid dat alleen deze speler moet horen. De handleiding over cutscenes is een groter uitgewerkt voorbeeld: de server beslist wanneer een speler de cutscene ziet en stuurt de shots naar die ene speler met FireClient, en zijn apparaat beweegt de camera.

Dit paar scripts toont een welkomstbericht als een speler binnenkomt. Het LocalScript bouwt zelf een kleine banner, dus je hoeft geen GUI in te stellen.

Script in ServerScriptService met de naam WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent

local function welcome(player: Player)
	-- Het eerste argument kiest welke client het bericht krijgt. Niemand anders ziet het.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- In Studio kun je binnenkomen voordat dit script verbonden is, dus we verwelkomen iedereen die er al is
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript in StarterPlayerScripts met de naam NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local player = Players.LocalPlayer

-- Een kleine banner bovenaan het scherm, gebouwd in code
local gui = Instance.new("ScreenGui")
gui.Name = "Notifications"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local label = Instance.new("TextLabel")
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 16)
label.Size = UDim2.fromOffset(420, 44)
label.BackgroundColor3 = Color3.fromRGB(18, 11, 31)
label.TextColor3 = Color3.new(1, 1, 1)
label.TextScaled = true
label.Visible = false
label.Parent = gui

local messageCount = 0

-- Hier is geen parameter player: de server heeft al gekozen wie het bericht krijgt
notify.OnClientEvent:Connect(function(message: string)
	messageCount += 1
	local thisMessage = messageCount
	label.Text = message
	label.Visible = true
	task.delay(4, function()
		if messageCount == thisMessage then -- verbergen, tenzij een nieuwer bericht het heeft vervangen
			label.Visible = false
		end
	end)
end)

De server stuurt het bericht bij PlayerAdded, en dat kan gebeuren voordat dit LocalScript zijn handler verbindt. Dat is geen probleem: Roblox zet RemoteEvent-berichten die binnenkomen voordat er een handler is in een wachtrij, en levert ze op volgorde af zodra de handler verbonden is.

De client hoeft zich niet tegen de server te beschermen: alleen servercode kan OnClientEvent starten. De annotatie message: string is voor de typecontrole; het is geen controle tijdens het uitvoeren.

Patroon 3: van server naar alle clients

FireAllClients stuurt hetzelfde bericht naar elke verbonden speler. Het heeft geen argument Player, en elke client ontvangt het bericht in dezelfde OnClientEvent als eerder, dus het script NotifyClient uit patroon 2 laat het al zien.

Dit Script kondigt aan iedereen aan wanneer een speler voor het eerst de finishlijn raakt. Voeg in Workspace een geankerde Part toe met de naam FinishLine, en voeg daarna het Script toe aan ServerScriptService.

Script in ServerScriptService met de naam FinishAnnouncer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local finishLine = workspace:WaitForChild("FinishLine") :: BasePart

local finished: { [Player]: boolean } = {}

finishLine.Touched:Connect(function(hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player or finished[player] then
		return -- geen speler of al aangekondigd
	end
	finished[player] = true

	-- Elke verbonden client start zijn handler OnClientEvent met deze tekst
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

Een exploiter kan Touched voor zijn personage vanaf elke afstand laten afgaan, maar voor een aankondiging die één keer per speler verschijnt is dat onschuldig. Geef je later een beloning voor de finish, voeg dan controles op de server toe voordat je hem uitdeelt, bijvoorbeeld een minimale tijd sinds het begin van de ronde.

FireAllClients bereikt alleen spelers die op dat moment verbonden zijn. Wie een seconde later binnenkomt, ziet het bericht niet meer. Dat is prima voor eenmalige momenten, zoals een aankondiging, een explosie-effect of een geluid, maar niet voor status zoals een rondetimer of de huidige fase van de game. Zet voor status een attribuut op de server, bijvoorbeeld ReplicatedStorage:SetAttribute("TimeLeft", 30), en lees het op de client met GetAttribute en GetAttributeChangedSignal("TimeLeft"). Attributen repliceren naar elke client, ook naar spelers die later binnenkomen.

RemoteFunction: als de client een antwoord nodig heeft

Een RemoteEvent werkt volgens het principe "versturen en vergeten". Een RemoteFunction laat de aanroeper wachten: InvokeServer zet de code die hem aanriep op pauze tot de serverfunctie OnServerInvoke een waarde teruggeeft, en geeft dan terug wat die functie teruggaf. Gebruik hem als de client niet verder kan zonder antwoord, bijvoorbeeld "was deze code juist?". Als je geen antwoord nodig hebt, raadt Roblox een RemoteEvent aan, omdat die niet wacht.

Voorbeeld: een veld waarin spelers een promocode invoeren. De server bewaart de codes, controleert de tekst en geeft twee waarden terug: of het gelukt is en het bericht dat getoond moet worden.

  1. Voeg in ReplicatedStorage.Remotes een RemoteFunction in met de naam RedeemCode.
  2. Voeg in StarterGui een ScreenGui in met de naam CodeGui, en daarin een TextBox met de naam CodeBox. Grootte en plek kies je zelf.
  3. Voeg het Script hieronder toe aan ServerScriptService, en het LocalScript in CodeBox.
Script in ServerScriptService met de naam RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction

-- De codes staan op de server, waar geen enkele speler ze kan lezen
local CODES: { [string]: number } = {
	LAUNCH = 100,
	THANKYOU = 50,
}
local MAX_LENGTH = 20
local COOLDOWN_SECONDS = 2

local usedCodes: { [Player]: { [string]: boolean } } = {}
local lastTry: { [Player]: number } = {}

-- Toewijzen met =. OnServerInvoke is een callback, geen event waar je Connect op doet.
redeemCode.OnServerInvoke = function(player: Player, code: unknown): (boolean, string)
	local now = os.clock()
	local last = lastTry[player]
	if last and now - last < COOLDOWN_SECONDS then
		return false, "Wait a moment before trying again"
	end
	lastTry[player] = now

	if type(code) ~= "string" or #code == 0 or #code > MAX_LENGTH then
		return false, "Type a code first"
	end

	local key = string.upper(code)
	local reward = CODES[key]
	if not reward then
		return false, "That code doesn't exist"
	end

	local used = usedCodes[player]
	if not used then
		used = {}
		usedCodes[player] = used
	end
	if used[key] then
		return false, "You already used that code"
	end

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if not (coins and coins:IsA("IntValue")) then
		return false, "Coins aren't set up in this game yet"
	end

	used[key] = true
	coins.Value += reward
	return true, `Code accepted: +{reward} coins`
end

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

Het telt op bij de stat Coins uit de handleiding over het leaderboard. Gebruikte codes worden alleen onthouden tot de speler vertrekt, dus in deze vorm kan een speler opnieuw joinen en dezelfde code nog eens invoeren. Als munten worden opgeslagen, zijn dat gratis munten bij elke keer opnieuw joinen: voordat je dit in een live game gebruikt, bewaar je de gebruikte codes van elke speler samen met zijn opgeslagen data in een datastore.

LocalScript in TextBox CodeBox met de naam RedeemClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
local box = script.Parent :: TextBox

local GREEN = Color3.fromRGB(46, 204, 113)
local RED = Color3.fromRGB(231, 76, 60)

box.FocusLost:Connect(function(enterPressed: boolean)
	local code = box.Text
	if not enterPressed or code == "" then
		return
	end
	box.Text = ""
	box.PlaceholderText = "Checking..."

	-- InvokeServer zet deze functie op pauze tot de callback van de server een waarde teruggeeft.
	-- pcall voorkomt dat het LocalScript stopt als de aanroep mislukt.
	local ok, accepted, message = pcall(function()
		return redeemCode:InvokeServer(code)
	end)

	if ok and type(message) == "string" then
		box.PlaceholderText = message
		box.PlaceholderColor3 = if accepted == true then GREEN else RED
	else
		box.PlaceholderText = "Something went wrong, try again"
		box.PlaceholderColor3 = RED
	end
end)

Een RemoteFunction heeft precies één callback op de server. Als twee scripts OnServerInvoke instellen op dezelfde RemoteFunction, werkt alleen de laatste.

Waarom InvokeClient gevaarlijk is

Een RemoteFunction werkt ook de andere kant op, met InvokeClient op de server en OnClientInvoke op de client. De documentatie van Roblox noemt drie serieuze risico's:

  • Als de callback van de client een fout geeft, geeft de server ook een fout.
  • Als de speler tijdens de aanroep vertrekt, geeft InvokeClient een fout.
  • Als de client nooit een waarde teruggeeft, wacht het serverscript eeuwig.

Een aangepaste client bepaalt zijn eigen callback, dus een valsspeler kan het derde geval expres veroorzaken en die serverthread zo lang vasthouden als hij wil. Gebruik FireClient om het scherm van een speler bij te werken. Heeft de server echt informatie van de client nodig, stuur dan een RemoteEvent, laat de client antwoorden via een ander RemoteEvent, en behandel een ontbrekend antwoord op de server als een normaal geval.

Controleer elk argument op de server

Een exploiter kan elke RemoteEvent of RemoteFunction zo vaak aanroepen als hij wil en met elke argumenten. Het enige wat hij niet kan vervalsen is de eerste parameter: Roblox vult zelf de Player in die het bericht stuurde. Alles wat daarna komt, moet je controleren voordat de server iets doet. Een remote verbergen of controleren in een LocalScript heeft geen zin, want de valsspeler bestuurt zijn eigen client.

Checklist voor de server
ControleVraag die de server steltVoorbeeld
TypeIs dit het type dat ik verwacht? Een Instance, en geen table die zo is gebouwd dat hij erop lijkt?typeof(part) == "Instance" and part:IsA("BasePart")
BereikIs het getal eindig en binnen de toegestane grenzen? Heeft de tekst een redelijke lengte?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
EigendomBezit deze speler het item, heeft hij genoeg geld, mag hij iets met dit object doen?Het item zit in zijn inventaris; de part staat in Paintable
AfstandIs het personage van de speler in de serverkopie van de wereld dichtbij genoeg? Houd een kleine marge voor lag.Niet verder dan 30 studs van de part
FrequentieStuurt deze speler niet te vaak?Cooldown per speler of een limiet met opgespaarde aanroepen

NaN verdient een aparte waarschuwing. Het is een getal, dus type(x) == "number" slaagt, maar elke vergelijking ermee geeft false, en een controle zoals x < 0 or x > 100 laat het gewoon door. math.isfinite(x) weigert NaN en beide oneindigheden.

Onthoud de grens van de afstandscontrole. Elke client bestuurt de physics van zijn eigen personage, dus een exploiter kan zijn personage voor de aanroep naar het doel verplaatsen. De controle stopt toch het simpelste misbruik, waarbij iemand vanaf één plek op de hele map werkt. Houd doelparts geankerd: de beveiligingsdocumentatie van Roblox noemt dat een exploiter netwerkeigendom kan krijgen over niet-geankerde parts bij hem in de buurt en ze naar zich toe kan trekken, en dat omzeilt de afstandscontrole.

Hier zijn dezelfde controles als ModuleScript dat je in elke handler van een remote kunt gebruiken.

ModuleScript in ServerScriptService met de naam RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Een echt getal tussen min en max. Weigert NaN en oneindig, die door
-- de gewone controle type(x) == "number" komen.
function RemoteGuard.number(value: unknown, min: number, max: number): number?
	if type(value) ~= "number" or not math.isfinite(value) then
		return nil
	end
	if value < min or value > max then
		return nil
	end
	return value
end

-- Een geheel getal tussen min en max, voor aantallen, indexen en tellers
function RemoteGuard.integer(value: unknown, min: number, max: number): number?
	local n = RemoteGuard.number(value, min, max)
	if n and n % 1 == 0 then
		return n
	end
	return nil
end

-- Tekst met een lengtelimiet. utf8.len geeft nil voor ongeldige UTF-8, die
-- datastores weigeren.
function RemoteGuard.text(value: unknown, maxLength: number): string?
	if type(value) ~= "string" or #value > maxLength or utf8.len(value) == nil then
		return nil
	end
	return value
end

-- Een Instance van de verwachte class binnen een container die je hebt toegestaan.
-- Een table die is gebouwd om op een Instance te lijken, komt niet door de typeof-controle.
function RemoteGuard.instanceIn(value: unknown, className: string, container: Instance): Instance?
	if typeof(value) ~= "Instance" then
		return nil
	end
	if not value:IsA(className) or not value:IsDescendantOf(container) then
		return nil
	end
	return value
end

-- True als het personage van de speler niet verder dan maxDistance studs van position is
function RemoteGuard.isNear(player: Player, position: Vector3, maxDistance: number): boolean
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if not (root and root:IsA("BasePart")) then
		return false
	end
	return (root.Position - position).Magnitude <= maxDistance
end

-- Frequentielimiet per speler. Elke speler kan `burst` aanroepen tegelijk doen en
-- krijgt elke seconde `perSecond` aanroepen terug. Geeft een functie terug die je aanroept
-- voor het werk: die antwoordt true (mag) of false (te vaak).
function RemoteGuard.limiter(burst: number, perSecond: number): (Player) -> boolean
	local buckets: { [Player]: { tokens: number, updated: number } } = {}

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

	return function(player: Player): boolean
		local now = os.clock()
		local bucket = buckets[player]
		if not bucket then
			bucket = { tokens = burst, updated = now }
			buckets[player] = bucket
		end
		bucket.tokens = math.min(burst, bucket.tokens + (now - bucket.updated) * perSecond)
		bucket.updated = now
		if bucket.tokens < 1 then
			return false
		end
		bucket.tokens -= 1
		return true
	end
end

return RemoteGuard

Bewaar het in ServerScriptService. Code daar komt nooit op de clients, dus niemand kan je controles lezen.

En hier is de handler uit patroon 1, herschreven met dit module. Vervang de inhoud van PaintServer:

Script in ServerScriptService met de naam PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" telt alleen voor de strikte typecontrole van Luau; tijdens het uitvoeren verandert het niets
local RemoteGuard = require(ServerScriptService:WaitForChild("RemoteGuard")) :: any

local paintRequest = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")

local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local canPaint = RemoteGuard.limiter(4, 4) -- een pakket van 4, daarna 4 per seconde

paintRequest.OnServerEvent:Connect(function(player: Player, partArg: unknown, colourArg: unknown)
	local part = RemoteGuard.instanceIn(partArg, "BasePart", paintable) :: BasePart?
	local colourIndex = RemoteGuard.integer(colourArg, 1, #PALETTE) :: number?
	if not part or not colourIndex then
		return
	end
	if not RemoteGuard.isNear(player, part.Position, 30) or not canPaint(player) then
		return
	end
	part.Color = PALETTE[colourIndex]
end)

De limiter verwijdert de gegevens van een speler als hij vertrekt, dus zijn table groeit niet de hele levensduur van de server door.

Bij wapens zijn deze controles het belangrijkst: laat de client nooit zeggen wie er geraakt is. De remote uit de handleiding over het zwaard heeft helemaal geen argumenten, en de server vindt de doelen zelf. De handleiding over wapens stuurt alleen het richtpunt, dat de server controleert op type, NaN en afstand voordat hij een eigen ray afvuurt.

Menu's volgen dezelfde regel: stuur de keuze, niet het resultaat. In de handleiding over NPC-dialogen stuurt de client alleen het nummer van de aangeklikte knop, en de server kijkt zelf wat dat antwoord oplevert. Het menu uit de handleiding over teleporters stuurt de naam van een punt, niet een positie, en de server zoekt het punt op in zijn eigen map en controleert hoeveel Wins ervoor nodig zijn.

Wat je wel en niet kunt versturen

Je kunt getallen, strings, booleans, Roblox-types zoals Vector3, CFrame, Color3 en items van een Enum versturen, Instances die beide kanten zien, en tables met al die dingen. Sommige waarden veranderen of verdwijnen onderweg:

Argumenten die anders aankomen dan ze verstuurd zijn
Je verstuurtWat er gebeurt
Een functieDe andere kant krijgt nil
Een table met een metatableDe metatable gaat verloren, samen met alles wat de table alleen via die metatable had
Een table met zowel getal- als stringsleutelsRoblox raadt dit af: stuur een zuivere array of een zuivere dictionary
Een table met nil-waarden erinVermijd dit: Roblox raadt nil op elke index af
Een table met sleutels van het type Instance, userdata of functionZulke sleutels worden strings
Een Instance die de ontvanger niet ziet, bijvoorbeeld uit ServerStorage of gemaakt in een LocalScriptDe andere kant krijgt nil
Elke tableDe ontvanger krijgt een kopie, niet dezelfde table

Een goede gewoonte: stuur ID's, geen objecten of waarden. De naam van een item, het nummer van een optie, een part die de server kan vinden en controleren. Daarna werkt de server met zijn eigen data.

Waarom een RemoteFunction nil teruggeeft

Als InvokeServer je nil geeft, loop dan deze punten op volgorde na:

  1. Een pad zonder returnwaarde. Elke uitgang van OnServerInvoke moet iets teruggeven. Een lege return in een vroege controle stuurt nil terug.
  2. return binnen een geneste functie. Een return binnen pcall(function() ... end), een handler van :Connect of task.spawn verlaat alleen die binnenste functie. Bewaar het resultaat, bijvoorbeeld local ok, data = pcall(...), en geef daarna data terug vanuit de callback zelf.
  3. Een waarde die de grens niet over kan. Een functie of een Instance die de client niet ziet (bijvoorbeeld alles in ServerStorage) komt aan als nil. Met instance streaming aan kan een part die de server net heeft gemaakt nog niet bij de client zijn als de functie terugkeert.
  4. Een ander script heeft de callback ingesteld. Alleen de laatste toewijzing van OnServerInvoke werkt. Zoek de naam van de remote in je scripts.

Als de aanroep helemaal niet terugkeert, heeft nog geen enkel script OnServerInvoke ingesteld (Roblox houdt aanroepen in een wachtrij tot dat gebeurt), of de callback hangt, bijvoorbeeld op een WaitForChild voor iets wat nooit verschijnt.

UnreliableRemoteEvent: voor constante kortstondige updates

Een UnreliableRemoteEvent heeft dezelfde methoden en events als een RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent en OnClientEvent. Het verschil is dat Roblox geen aflevering en geen volgorde garandeert. Een bericht kan zonder opnieuw verzenden worden weggegooid als:

  • het onderweg verloren gaat of te lang wacht in een overbelast netwerk
  • de data groter is dan 1000 bytes
  • de client vaker stuurt dan de limiet (het teveel wordt weggegooid, niet uitgesteld)
  • er bij aankomst geen enkele handler verbonden is (het wordt weggegooid, niet in een wachtrij gezet)

Berichten kunnen ook in de verkeerde volgorde aankomen, en die volgorde staat helemaal los van je RemoteEvents of RemoteFunctions. Gebruik het als alleen de nieuwste waarde telt en de volgende update over een fractie van een seconde komt: waar een speler op richt, de positie van een cosmetisch effect, een waarde die elk frame verandert. Is de volgorde belangrijk, zet dan in elk bericht een volgnummer of tijdstempel en negeer alles wat ouder is dan het laatst verwerkte.

Gebruik het nooit voor iets wat precies één keer moet gebeuren, zoals een aankoop, schade, een beloning of de start van een ronde. En controleer de argumenten op de server net zo als bij een RemoteEvent.

Volgorde van aflevering en frequentielimieten

De afleveringsgaranties van Roblox gelden per verbinding in één richting: van de server naar één client of van één client naar de server.

  • RemoteEvents zijn betrouwbaar en op volgorde. Verloren berichten worden opnieuw verstuurd zolang de ontvanger verbonden blijft, en berichten komen aan in de volgorde waarin je ze verstuurde, ook via verschillende RemoteEvents. Als de server aan een speler A stuurt, dan B, dan A, krijgt die speler A, B, A.
  • De volgorde gaat over het moment waarop handlers starten. Als een handler de controle afstaat, bijvoorbeeld met task.wait of WaitForChild, kan het volgende bericht al verwerkt worden voordat het eerste klaar is.
  • RemoteFunctions en RemoteEvents hebben geen onderlinge volgorde. Als je code van een strikte volgorde afhangt, stuur dan samenhangende berichten via één type remote of voeg je eigen volgnummer toe.
  • Wijzigingen van eigenschappen en attributen hebben geen volgorde ten opzichte van remotes. Als de server een eigenschap verandert en daarna een remote aanroept, kan de client een van beide als eerste zien. Luister naar de wijziging zelf, bijvoorbeeld met GetPropertyChangedSignal, en ga er niet van uit dat ze al is aangekomen.
  • Er is nog geen handler. RemoteEvent-berichten staan in een wachtrij tot er een handler verbonden is. De wachtrij heeft grenzen: als hij vol is, worden de volgende berichten weggegooid en verschijnt in Output de fout Remote event invocation discarded.
  • Een speler die vertrekt verliest alle berichten die hem nog niet bereikt hadden.

Frequentielimiet. RemoteEvent- en UnreliableRemoteEvent-berichten van client naar server zijn beperkt tot ongeveer 500 verzoeken per seconde per client, volgens de documentatie op 30 september 2026. De limiet geldt voor alle remotes van hetzelfde type samen, dus een drukke remote opsplitsen in tien verhoogt hem niet. Boven de limiet worden RemoteEvent-berichten later verwerkt en behouden ze hun volgorde, terwijl UnreliableRemoteEvent-berichten worden weggegooid. De limiet van de engine houdt één speler er niet van af om je remote 50 keer per seconde aan te roepen, dus elke handler die iets verandert heeft toch zijn eigen limiet per speler nodig.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent of attribuut?

Hoe je kiest hoe client en server communiceren
GebruikWaarvoorVoorbeeldLet op
RemoteEventBerichten in één richting die moeten aankomen, en op volgordeClient: "verf deze part". Server: "toon deze melding"Controleer elk argument op de server
RemoteFunction met InvokeServerDe client heeft een antwoord nodig voordat hij verder kanEen promocode invoeren, een aankoop bevestigenDe aanroeper wacht; elk pad moet een waarde teruggeven
RemoteFunction met InvokeClientBijna nooitGebruik in plaats daarvan FireClientEen client die een fout krijgt, vertrekt of niet antwoordt, breekt de aanroep op de server of laat hem hangen
UnreliableRemoteEventFrequente updates waarbij alleen de laatste teltRichting van het richten, cosmetische effectenBerichten raken kwijt of veranderen van volgorde; datalimiet 1000 bytes
Attribuut of value-object dat de server insteltGedeelde status die altijd zichtbaar moet zijn, ook voor spelers die later binnenkomenRondetimer, fase van de game, of een deur open isAlleen wijzigingen van de server bereiken iedereen; clients luisteren met GetAttributeChangedSignal of Changed
BindableEventCommunicatie tussen scripts aan dezelfde kantHet ene serverscript laat een ander weten dat de ronde voorbij isGaat niet tussen server en client

Een volledig voorbeeld van hoe een RemoteFunction en controles samenwerken waar spelers betalen, vind je in de handleiding hoe je een shop-GUI maakt. Wat de regel over attributen betreft: het serverscript uit de handleiding over deuren zet het attribuut Open op elke deur telkens als die beweegt, zodat elk LocalScript erop kan reageren.

Veelvoorkomende fouten en oplossingen

De meeste problemen met remotes zie je in het venster Output (open het via het menu Window of het tabblad Script). Kijk daar eerst, en zoek dan je symptoom hieronder. De handleiding over scriptfouten behandelt algemene foutmeldingen uitgebreider.

Infinite yield possible bij WaitForChild voor een remote

Het script wacht op een remote die nooit verschijnt. Controleer dat de naam en de hoofdletters precies kloppen en dat de remote in ReplicatedStorage staat, niet in ServerStorage of ServerScriptService, die clients niet zien.

De server krijgt de verkeerde waarden, één plek verschoven

Het LocalScript gaf de speler zelf mee, zoals in remote:FireServer(player, 5). Roblox voegt de afzender al als eerste parameter toe, dus de server ziet (player, player, 5). Roep remote:FireServer(5) aan.

Er gebeurt niets als ik de remote aanroep

Controleer dat elke aanroep van de juiste kant komt: FireServer en InvokeServer werken alleen vanuit clientcode, en FireClient, FireAllClients en InvokeClient alleen vanuit een Script op de server. Een LocalScript start nooit in ServerScriptService, ServerStorage of direct in Workspace; zet het in StarterPlayerScripts, StarterGui, StarterCharacterScripts of StarterPack. Zoek daarna in Output naar een fout in de handler.

Remote event invocation discarded

Er kwamen berichten binnen voor een RemoteEvent zonder verbonden handler, en de wachtrij liep vol. Meestal loopt het script met de handler vast op een fout voor de regel met :Connect, staat het uit, of hangt het in afwachting van iets wat nooit laadt. Verbind handlers dicht bij het begin van het script.

Bij mij werkt het, maar andere spelers zien de wijziging niet

De wijziging is op de client gedaan, in een LocalScript of in een handler van OnClientEvent. Doe het in de handler OnServerEvent op de server.

InvokeServer keert nooit terug

Ofwel heeft geen enkel script OnServerInvoke ingesteld (Roblox houdt aanroepen in een wachtrij tot dat gebeurt), ofwel hangt de callback op iets wat de controle afstaat, zoals WaitForChild of een verzoek aan een datastore. Zet een print aan het begin en het einde van de callback om te zien waar hij stopt.

Maak het met RoCode

RoCode kan dit ook voor je instellen, direct in de place die je open hebt. RoCode is een AI-agent die via een plugin voor Roblox Studio werkt, dus hij maakt de remotes en scripts in je Explorer in plaats van code te geven die je moet plakken.

Jij typt

Laat spelers parts in de map Paintable verven met een klik. Gebruik een RemoteEvent en houd de controles op de server: alleen parts uit die map, niet verder dan 30 studs en niet meer dan een paar keer verven per seconde.

RoCode doet
  • Bekijkt meestal eerst de place met Search Game en Search Scripts, op zoek naar een bestaande map Remotes of handler, en gebruikt je mappen als die er zijn
  • Maakt de RemoteEvent in ReplicatedStorage met Create Instance en schrijft het Script voor de server en het LocalScript met Create Script
  • Controleert voor het afronden met Check Script in Studio of elk script compileert. Dat vangt compileerfouten op, geen logische fouten: het doet geen typecontrole, draait geen linter en voert je code niet uit
  • Stuurt wijzigingen in pakketten, en elk pakket is een punt om ongedaan te maken in de geschiedenis van Studio

Met plugin 3.9 of nieuwer kan RoCode een korte playtest draaien en de fouten lezen, en met plugin 3.9.11 of nieuwer kan hij een testpersonage besturen, maar op parts in het 3D-venster klikt hij niet. Klik zelf op Play en probeer de controles te breken, bijvoorbeeld door een part te verven vanaf de andere kant van de map. Gaat er iets fout, dan kan Check Output de regels Server en Client van je laatste playtest lezen. De meeste gamesystemen communiceren via zulke remotes, dus je komt ze weer tegen als je een game systeem voor systeem bouwt met RoCode. Hoe RoCode verbinding maakt met Studio.

Veelgestelde vragen

Wat betekent securing the client-server boundary in Roblox?

Zo heet de pagina in de documentatie van Roblox over de beveiliging van remotes, en het idee is simpel: alles wat de client via een RemoteEvent of RemoteFunction stuurt, kan van een exploiter komen, dus de server controleert het voordat hij iets doet. Controleer het type van elk argument, houd getallen binnen redelijke grenzen, controleer dat de speler dit nu mag doen, en beperk hoe vaak elke speler de remote kan aanroepen. De checklist voor controles hierboven laat elke controle in code zien.

Is het veilig om een RemoteFunction te gebruiken?

InvokeServer is zo veilig als je callback op de server: controleer de argumenten en beperk de frequentie, net als bij elke RemoteEvent. De riskante richting is InvokeClient, omdat een client die een fout krijgt, vertrekt of nooit een waarde teruggeeft, de aanroep op de server breekt of laat hangen.

Kunnen exploiters mijn remotes zien en aanroepen?

Ja. Alles in ReplicatedStorage bereikt elke client, en een aangepaste client kan elke remote met elke argumenten aanroepen. Remotes hernoemen of verbergen maakt ze niet veilig; wat ze veilig maakt, is elk argument op de server controleren.

Kan een client een RemoteEvent naar een andere client sturen?

Niet direct. Stuur het naar de server, controleer het daar, en gebruik dan FireClient of FireAllClients.

Hoe vaak mag je een RemoteEvent aanroepen?

De documentatie van Roblox noemt een limiet van ongeveer 500 verzoeken per seconde per client voor RemoteEvent- en UnreliableRemoteEvent-berichten naar de server, gedeeld door alle remotes van hetzelfde type. Blijf daar ruim onder en geef elke handler zijn eigen limiet per speler.

Bereikt FireAllClients spelers die later binnenkomen?

Nee. Het bereikt de spelers die op dat moment verbonden zijn. Voor status die latere spelers nodig hebben, zet je op de server een attribuut of value-object.

Wat is het verschil tussen RemoteEvent en BindableEvent?

Een RemoteEvent gaat tussen server en client. Een BindableEvent verbindt scripts aan dezelfde kant, bijvoorbeeld twee serverscripts.

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.