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 (
InvokeServerenOnServerInvoke) alleen als de client een antwoord nodig heeft. VermijdInvokeClient: 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
Waarom je RemoteEvents nodig hebt
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.
| Richting | Afzender roept aan | Ontvanger verbindt met | Ontvanger krijgt |
|---|---|---|---|
| Van client naar server | remote:FireServer(...) in een LocalScript | remote.OnServerEvent in een Script | De Player die het bericht stuurde, daarna je argumenten |
| Van server naar één client | remote:FireClient(player, ...) in een Script | remote.OnClientEvent in een LocalScript | Alleen je argumenten |
| Van server naar alle clients | remote:FireAllClients(...) in een Script | remote.OnClientEvent in een LocalScript | Alleen je argumenten |
| Client vraagt, server antwoordt | remoteFunction: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.
- Beweeg in de Explorer je muis over ReplicatedStorage, klik op de knop + en voeg een Folder in. Noem de map
Remotes. - Beweeg je muis over
Remotes, klik op + en voeg een RemoteEvent in. Geef hem een naam die zegt waar hij voor is, bijvoorbeeldPaintRequest. - Herhaal dit voor elke remote. Deze handleiding gebruikt twee RemoteEvents (
PaintRequestenNotify) en één RemoteFunction (RedeemCode).
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.
- Voeg in Workspace een Folder in met de naam
Paintableen zet er een paar geankerde Parts in. - Controleer dat
ReplicatedStorage.Remoteseen RemoteEvent met de naamPaintRequestbevat. - Voeg een Script met de naam
PaintServerin ServerScriptService in en een LocalScript met de naamPaintClientin StarterPlayer, StarterPlayerScripts, met de code hieronder.
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.
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.
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
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.
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.
- Voeg in
ReplicatedStorage.Remoteseen RemoteFunction in met de naamRedeemCode. - Voeg in StarterGui een ScreenGui in met de naam
CodeGui, en daarin een TextBox met de naamCodeBox. Grootte en plek kies je zelf. - Voeg het Script hieronder toe aan ServerScriptService, en het LocalScript in
CodeBox.
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.
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
InvokeClienteen 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.
| Controle | Vraag die de server stelt | Voorbeeld |
|---|---|---|
| Type | Is 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") |
| Bereik | Is het getal eindig en binnen de toegestane grenzen? Heeft de tekst een redelijke lengte? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Eigendom | Bezit 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 |
| Afstand | Is 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 |
| Frequentie | Stuurt 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.
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:
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:
| Je verstuurt | Wat er gebeurt |
|---|---|
| Een functie | De andere kant krijgt nil |
| Een table met een metatable | De metatable gaat verloren, samen met alles wat de table alleen via die metatable had |
| Een table met zowel getal- als stringsleutels | Roblox raadt dit af: stuur een zuivere array of een zuivere dictionary |
Een table met nil-waarden erin | Vermijd dit: Roblox raadt nil op elke index af |
| Een table met sleutels van het type Instance, userdata of function | Zulke sleutels worden strings |
| Een Instance die de ontvanger niet ziet, bijvoorbeeld uit ServerStorage of gemaakt in een LocalScript | De andere kant krijgt nil |
| Elke table | De 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:
- Een pad zonder returnwaarde. Elke uitgang van
OnServerInvokemoet iets teruggeven. Een legereturnin een vroege controle stuurtnilterug. - return binnen een geneste functie. Een
returnbinnenpcall(function() ... end), een handler van:Connectoftask.spawnverlaat alleen die binnenste functie. Bewaar het resultaat, bijvoorbeeldlocal ok, data = pcall(...), en geef daarnadataterug vanuit de callback zelf. - 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. - Een ander script heeft de callback ingesteld. Alleen de laatste toewijzing van
OnServerInvokewerkt. 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.waitofWaitForChild, 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?
| Gebruik | Waarvoor | Voorbeeld | Let op |
|---|---|---|---|
| RemoteEvent | Berichten in één richting die moeten aankomen, en op volgorde | Client: "verf deze part". Server: "toon deze melding" | Controleer elk argument op de server |
RemoteFunction met InvokeServer | De client heeft een antwoord nodig voordat hij verder kan | Een promocode invoeren, een aankoop bevestigen | De aanroeper wacht; elk pad moet een waarde teruggeven |
RemoteFunction met InvokeClient | Bijna nooit | Gebruik in plaats daarvan FireClient | Een client die een fout krijgt, vertrekt of niet antwoordt, breekt de aanroep op de server of laat hem hangen |
| UnreliableRemoteEvent | Frequente updates waarbij alleen de laatste telt | Richting van het richten, cosmetische effecten | Berichten raken kwijt of veranderen van volgorde; datalimiet 1000 bytes |
| Attribuut of value-object dat de server instelt | Gedeelde status die altijd zichtbaar moet zijn, ook voor spelers die later binnenkomen | Rondetimer, fase van de game, of een deur open is | Alleen wijzigingen van de server bereiken iedereen; clients luisteren met GetAttributeChangedSignal of Changed |
| BindableEvent | Communicatie tussen scripts aan dezelfde kant | Het ene serverscript laat een ander weten dat de ronde voorbij is | Gaat 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (in het Engels). FireServer, FireClient, InvokeServer, risico's van InvokeClient, beperkingen van argumenten en afleveringsgaranties
- Roblox Creator Docs: Securing the client-server boundary (in het Engels). Niveaus van controle, NaN, frequentielimieten, doorsturen van client naar client
- Roblox Creator Docs: Security and cheat mitigation tactics (in het Engels). Wat een aangepaste client kan, en het gezag van de server
- Roblox Creator Docs: Network ownership, movement validation, and physics (in het Engels). Waarom de client zijn eigen personage bestuurt, en de grenzen van afstandscontroles
- Roblox Engine API: RemoteEvent (in het Engels). Frequentielimiet en de fout invocation discarded
- Roblox Engine API: RemoteFunction (in het Engels). OnServerInvoke, waarschuwingen over InvokeClient en voorzorgen bij streaming
- Roblox Engine API: UnreliableRemoteEvent (in het Engels). Datalimiet van 1000 bytes
- Roblox Creator Docs: Properties and attributes (in het Engels). Volgorde van replicatie tussen wijzigingen van eigenschappen en remote events
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.