Kort fortalt
En RemoteEvent er et objekt, der som regel ligger i ReplicatedStorage og sender beskeder over grænsen mellem klient og server. Et LocalScript kalder FireServer, og serveren modtager beskeden i OnServerEvent, hvor den Player, der sendte den, er tilføjet som første argument. Serveren kalder FireClient(player, ...) eller FireAllClients(...), og LocalScripts modtager beskeden i OnClientEvent.
- Brug kun RemoteFunction (
InvokeServerogOnServerInvoke), når klienten har brug for et svar. UndgåInvokeClient: en klient, der fik en fejl, gik ud eller aldrig returnerede en værdi, ødelægger kaldet på serveren. - Stol aldrig på det, klienten sender. Tjek på serveren type, interval og ejerskab for hvert argument, afstanden til spilleren og hvor ofte den kalder remoten.
- Funktioner, metatabeller og objekter, som den anden side ikke kan se, overlever ikke overførslen. UnreliableRemoteEvent kan miste beskeder eller ændre deres rækkefølge og kasserer alle data over 1000 bytes.
På denne side
Hvorfor RemoteEvents er nødvendige
Ethvert Roblox-spil kører som én server plus én klient for hver spiller. Serveren bestemmer: et nyt objekt eller en ændret egenskab når kun ud til alle spillere, når serveren laver det. En ændring lavet i et LocalScript bliver på den ene enhed, med få undtagelser som spillerens egen karakter, hvis bevægelse styres af klienten. Derfor skal klienten, når et klik eller et tastetryk skal ændre den fælles verden, bede serveren om det, og når serveren vil have én spillers skærm til at reagere, skal den fortælle klienten det. Hvis opdelingen i Script og LocalScript er ny for dig, så læs først Script vs LocalScript vs ModuleScript (på engelsk). Hvis selve scripting er nyt, så start med, hvordan man skriver scripts i Roblox Studio.
Til at krydse den grænse giver Roblox tre objekter:
- RemoteEvent: en besked én vej. Afsenderen fortsætter straks.
- RemoteFunction: en forespørgsel, der venter på svar. Den kaldende kode holder pause, indtil den anden side returnerer en værdi.
- UnreliableRemoteEvent: en besked én vej, der kan gå tabt eller komme i forkert rækkefølge, men belaster netværket mindre. Passer til data, der ændrer sig hele tiden.
| Retning | Afsenderen kalder | Modtageren forbinder til | Modtageren får |
|---|---|---|---|
| Fra klient til server | remote:FireServer(...) i et LocalScript | remote.OnServerEvent i et Script | Den Player, der sendte beskeden, og derefter dine argumenter |
| Fra server til én klient | remote:FireClient(player, ...) i et Script | remote.OnClientEvent i et LocalScript | Kun dine argumenter |
| Fra server til alle klienter | remote:FireAllClients(...) i et Script | remote.OnClientEvent i et LocalScript | Kun dine argumenter |
| Klienten spørger, serveren svarer | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player og derefter dine argumenter. Den, der kaldte, får det, funktionen returnerede |
Klienter kan ikke sende beskeder direkte til hinanden. For at sende noget fra én spiller til de andre sender du det til serveren, tjekker det der og lader serveren sende det videre med FireClient eller FireAllClients. Ifølge Robloxs sikkerhedsanbefalinger fungerer serveren her som dørvogter, ikke som en simpel videresender.
Hvor remotes skal ligge
En remote skal ligge et sted, hvor både serveren og klienterne kan se den. Det almindelige sted er ReplicatedStorage; Robloxs dokumentation nævner, at Workspace eller et Tool også kan bruges i nogle tilfælde. ServerStorage og ServerScriptService er kun tilgængelige for serveren, så et LocalScript, der venter på en remote derfra, venter for evigt.
- I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og indsætter en Folder. Kald mappen
Remotes. - Hold musen over
Remotes, klik på +, og indsæt en RemoteEvent. Omdøb den, så navnet beskriver formålet, for eksempelPaintRequest. - Gentag for hver remote. Denne guide bruger to RemoteEvents (
PaintRequestogNotify) og é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
Scripts i denne guide finder remotes med WaitForChild. Den returnerer straks, hvis remoten allerede er der, og venter, hvis den ikke er der endnu, for eksempel når et server-script opretter remotes under spillet. Lav en separat remote for hver slags forespørgsel: så tjekker hver handler på serveren én form for argumenter, og det er meget nemmere at gøre rigtigt end med én remote til alt.
Mønster 1: fra klient til server, med tjek på serveren
Den mest almindelige opgave: spilleren gør noget på sin skærm, og serveren afgør, hvad der sker. Her trykker spilleren på Q for at vælge en af fire farver og klikker eller trykker på en part for at male den. Alle ser den nye farve, fordi serveren maler.
Klienten sender to ting: hvilken part og farvens nummer. Selve farven sender den aldrig, og i andre spil skal den på samme måde aldrig sende en pris, en belønning eller en skadesværdi. En modificeret klient kan sende hvad som helst, så de rigtige data (her paletten) holder serveren, og argumenterne behandler den som en forespørgsel, der skal tjekkes.
- Indsæt en Folder med navnet
Paintablei Workspace, og læg nogle ankrede Parts i den. - Tjek, at der er en RemoteEvent med navnet
PaintRequestiReplicatedStorage.Remotes. - Indsæt et Script med navnet
PaintServeri ServerScriptService og et LocalScript med navnetPaintClienti StarterPlayer, StarterPlayerScripts, med koden nedenfor.
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")
-- Farverne tilhører serveren. Klienten sender kun et nummer, der vælger en af dem.
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 mellem karakteren og parten
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- Den første parameter er altid den spiller, der kaldte remoten. Den indsættes af Roblox,
-- så den kan man stole på. Alt efter den kom fra klienten, og det kan man ikke stole på.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Type: en rigtig part, ikke en tabel, der foregiver at være en
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Interval: et heltal fra 1 til 4. NaN og uendelig sorteres også fra her.
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. Tilladt mål: kun parts i mappen Paintable, intet andet i spillet
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Afstand: spillerens karakter skal være tæt på parten
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. Hyppighedsgrænse: én maling pr. spiller hvert kvarte sekund
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)
Hvert tjek, der ikke bestås, laver bare return. Der er ingen grund til at forklare en snyderklient, hvorfor den blev afvist.
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 rigtige farver holder serveren
local selectedColour = 1
-- Strålen kan kun ramme parts inde i mappen Paintable
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
if gameProcessed then
return -- tasten eller klikket gik til chatten eller en knap
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
-- Vi beder, vi beordrer ikke: serveren afgør, om der skal males
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed er true, når motoren allerede har håndteret dette input, som regel i brugerfladen: et klik på en knap eller taster skrevet i et tekstfelt som chatlinjen. Takket være dette tjek ændrer bogstavet Q, skrevet i en besked, ikke farven.
Mønster 2: fra server til én klient
Serveren sender en besked til én spiller med FireClient. Det første argument er den Player, den er adresseret til, og handleren på klienten får kun argumenterne efter den. Brug det til alt personligt: en notifikation, et belønningsvindue, en lyd, som kun den spiller skal høre. Cutscene-guiden er et større gennemgået eksempel: serveren afgør, hvornår spilleren ser en cutscene, og sender dens frames til den ene spiller med FireClient, mens spillerens enhed flytter kameraet.
Dette par scripts viser en velkomst, når en spiller kommer ind. LocalScriptet bygger selv et lille banner, så du behøver ikke at sætte en GUI op.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local function welcome(player: Player)
-- Det første argument vælger, hvilken klient der får beskeden. Ingen andre ser den.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- I Studio kan du komme ind, før dette script forbinder, så vi byder alle velkommen, der allerede er her
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
-- Et lille banner øverst på skærmen, bygget i koden
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
-- Her er der ingen player-parameter: serveren har allerede valgt, hvem der får beskeden
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 -- skjul, hvis den ikke er erstattet af en nyere besked
label.Visible = false
end
end)
end)
Serveren sender beskeden ved PlayerAdded, og det kan ske, før dette LocalScript forbinder sin handler. Det er i orden: Roblox sætter RemoteEvent-beskeder, der kom, før handleren fandtes, i kø og leverer dem i rækkefølge, så snart handleren forbinder.
Klienten behøver ikke at beskytte sig mod serveren: kun serverkode kan udløse OnClientEvent. Annotationen message: string er til typekontrol; det er ikke et tjek under kørsel.
Mønster 3: fra server til alle klienter
FireAllClients sender den samme besked til hver forbundet spiller. Den har intet Player-argument, og hver klient modtager beskeden i den samme OnClientEvent som før, så scriptet NotifyClient fra mønster 2 viser den allerede.
Dette Script meddeler alle, når en spiller første gang rører målstregen. Tilføj en ankret Part med navnet FinishLine i Workspace, og tilføj derefter Scriptet i 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 -- ikke en spiller eller allerede meddelt
end
finished[player] = true
-- Hver forbundet klient kører sin OnClientEvent-handler med denne tekst
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
En exploiter kan udløse Touched for sin karakter fra en hvilken som helst afstand, men for en meddelelse, der vises én gang pr. spiller, er det harmløst. Hvis du senere giver en belønning for at nå målet, så tilføj tjek på serveren før udbetalingen, for eksempel en minimumstid fra rundens start.
FireAllClients når kun de spillere, der er forbundet i det øjeblik. Den, der kommer ind et sekund senere, ser ikke beskeden. Det passer til enkeltstående øjeblikke som en meddelelse, en eksplosionseffekt eller en lyd, men ikke til tilstand som en rundetimer eller spillets nuværende fase. Til tilstand sætter du en attribut på serveren, for eksempel ReplicatedStorage:SetAttribute("TimeLeft", 30), og læser den på klienten med GetAttribute og GetAttributeChangedSignal("TimeLeft"). Attributter replikeres til hver klient, også til spillere, der kommer senere.
RemoteFunction: når klienten har brug for et svar
En RemoteEvent virker efter princippet "send og glem". En RemoteFunction får den, der kalder, til at vente: InvokeServer sætter den kode, der kaldte den, på pause, indtil serverens funktion OnServerInvoke returnerer en værdi, og giver derefter det, den returnerede. Brug den, når klienten ikke kan fortsætte uden et svar, for eksempel "var denne kode rigtig?". Når der ikke skal bruges et svar, anbefaler Roblox en RemoteEvent, fordi den ikke venter.
Eksempel: et felt, hvor spillerne skriver en kampagnekode. Serveren holder koderne, tjekker teksten og returnerer to værdier: om det virkede, og den besked, der skal vises.
- Indsæt en RemoteFunction med navnet
RedeemCodeiReplicatedStorage.Remotes. - Indsæt en ScreenGui med navnet
CodeGuii StarterGui og indeni en TextBox med navnetCodeBox. Vælg størrelse og placering efter smag. - Tilføj Scriptet nedenfor i ServerScriptService og LocalScriptet inde i
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Koderne bor på serveren, hvor ingen spiller kan læse dem
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 } = {}
-- Tildel med =. OnServerInvoke er et callback, ikke et event, man forbinder til med Connect.
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)
Det lægger til statistikken Coins fra guiden til leaderboards. Brugte koder huskes kun, indtil spilleren går, så i denne form kan en spiller komme ind igen og indtaste den samme kode igen. Hvis mønterne gemmes, er det gratis mønter ved hvert genbesøg: før du bruger det i et live spil, så gem hver spillers brugte koder sammen med spillerens gemte data i et datalager.
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 sætter denne funktion på pause, indtil serverens callback returnerer en værdi.
-- pcall forhindrer LocalScriptet i at stoppe, hvis kaldet fejlede.
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)
En RemoteFunction har præcis ét callback på serveren. Hvis to scripts sætter OnServerInvoke på den samme RemoteFunction, virker kun det sidste.
Hvorfor InvokeClient er farlig
En RemoteFunction virker også den anden vej, med InvokeClient på serveren og OnClientInvoke på klienten. Robloxs dokumentation nævner tre alvorlige risici:
- Hvis klientens callback giver en fejl, giver serveren også en fejl.
- Hvis spilleren går under kaldet, giver
InvokeClienten fejl. - Hvis klienten aldrig returnerer en værdi, venter server-scriptet for evigt.
En modificeret klient styrer sit eget callback, så en snyder kan bevidst fremkalde det tredje tilfælde og holde den servertråd så længe, den vil. For at opdatere en spillers skærm bruger du FireClient. Hvis serveren virkelig har brug for information fra klienten, så send en RemoteEvent, lad klienten svare via en anden RemoteEvent, og betragt et manglende svar som et normalt tilfælde på serveren.
Tjek hvert argument på serveren
En exploiter kan kalde enhver RemoteEvent eller RemoteFunction så mange gange, den vil, og med alle mulige argumenter. Det eneste, den ikke kan forfalske, er den første parameter: Roblox indsætter selv den Player, der sendte beskeden. Alt, der kommer efter, skal tjekkes, før serveren handler. Det nytter ikke at skjule remoten eller tjekke i et LocalScript, fordi snyderen styrer sin egen klient.
| Tjek | Spørgsmålet, serveren stiller | Eksempel |
|---|---|---|
| Type | Er det den type, jeg forventer? En Instance og ikke en tabel bygget til at ligne en? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Interval | Er tallet endeligt og inden for de tilladte grænser? Har teksten en rimelig længde? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Ejerskab | Ejer spilleren genstanden, har den penge nok, har den ret til at handle med dette objekt? | Genstanden er i spillerens inventar; parten ligger inde i Paintable |
| Afstand | Er spillerens karakter tæt nok på i serverens kopi af verden? Giv lidt margin til lag. | Højst 30 studs fra parten |
| Hyppighed | Sender denne spiller for ofte? | Cooldown pr. spiller eller en grænse med opsparede kald |
NaN fortjener en særlig advarsel. Det er et tal, så type(x) == "number" består, men enhver sammenligning med det giver false, og et tjek som x < 0 or x > 100 lader det slippe igennem. math.isfinite(x) afviser NaN og begge uendeligheder.
Husk grænsen for afstandstjekket. Hver klient styrer fysikken for sin karakter, så en exploiter kan flytte karakteren hen til målet før kaldet. Tjekket stopper stadig det simpleste misbrug, hvor man fra ét sted handler på hele kortet. Hold målparts ankrede: Robloxs sikkerhedsdokumentation nævner, at en exploiter kan få network ownership over ikke-ankrede parts i nærheden og trække dem tættere på, og det kommer uden om afstandstjekket.
Her er de samme tjek som et ModuleScript, du kan bruge i hver remote-handler.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Et rigtigt tal mellem min og max. Afviser NaN og uendelig, som består
-- det almindelige tjek type(x) == "number".
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
-- Et heltal mellem min og max, til antal, indekser og tællere
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 med længdegrænse. utf8.len returnerer nil for ugyldig UTF-8, som
-- datalagre afviser.
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
-- En Instance af den forventede klasse inde i en container, du har tilladt.
-- En tabel bygget til at ligne en Instance består ikke typeof-tjekket.
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, når spillerens karakter er højst maxDistance studs fra position
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
-- Hyppighedsgrænse pr. spiller. Hver spiller kan lave `burst` kald på én gang og
-- får `perSecond` kald tilbage hvert sekund. Returnerer en funktion, der kaldes
-- før arbejdet: den svarer true (tilladt) eller false (for ofte).
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
Hold den i ServerScriptService. Kode derfra når aldrig ud til klienterne, så ingen kan læse dine tjek.
Og her er handleren fra mønster 1, skrevet om med den. Erstat indholdet af PaintServer:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" har kun betydning for Luaus strenge typekontrol; under kørsel ændrer det ingenting
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) -- en pakke på 4, derefter 4 i sekundet
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)
Begrænseren sletter spillerens post, når den går, så dens tabel vokser ikke, så længe serveren kører.
I våben er disse tjek vigtigst: lad aldrig klienten melde, hvem der blev ramt. Remoten fra sværd-guiden har slet ingen argumenter, og serveren finder selv målene. Våben-guiden sender kun sigtepunktet, som serveren tjekker for type, NaN og afstand, før den sender sin egen stråle.
Menuer følger samme regel: send valget, ikke resultatet. I guiden til NPC-dialoger sender klienten kun nummeret på den knap, der blev trykket på, og serveren ser selv, hvad det svar giver. Menuen fra teleport-guiden sender stedets navn, ikke en position, og serveren finder stedet i sin mappe og tjekker, hvor mange Wins det kræver.
Hvad du kan og ikke kan sende
Du kan sende tal, strenge, booleske værdier, Roblox-typer som Vector3, CFrame, Color3 og Enum-elementer, Instances, som begge sider kan se, og tabeller af alt det. Nogle værdier ændres eller forsvinder undervejs:
| Du sender | Hvad der sker |
|---|---|
| En funktion | Den anden side får nil |
| En tabel med en metatabel | Metatabellen går tabt sammen med alt, hvad tabellen kun havde via den |
| En tabel, hvor tal- og strengnøgler er blandet | Roblox fraråder det: send et rent array eller en ren ordbog |
En tabel med nil-værdier indeni | Undgå det: Roblox fraråder nil på ethvert indeks |
| En tabel med nøgler af typen Instance, userdata eller function | Sådanne nøgler bliver til strenge |
| En Instance, som modtageren ikke kan se, for eksempel fra ServerStorage eller oprettet i et LocalScript | Den anden side får nil |
| Enhver tabel | Modtageren får en kopi, ikke den samme tabel |
En god vane: send identifikatorer, ikke objekter eller værdier. Et genstandsnavn, et nummer på en mulighed, en part, som serveren kan finde og tjekke. Derefter arbejder serveren med sine egne data.
Hvorfor RemoteFunction returnerer nil
Hvis InvokeServer giver dig nil, så gå disse punkter igennem i rækkefølge:
- En vej uden returværdi. Hver udgang fra
OnServerInvokeskal returnere noget. En tomreturni et tidligt tjek senderniltilbage. - return inde i en indlejret funktion.
returninde ipcall(function() ... end), en:Connect-handler ellertask.spawnforlader kun den indre funktion. Gem resultatet, for eksempellocal ok, data = pcall(...), og returnér derefterdatafra selve callbacket. - En værdi, der ikke kan krydse grænsen. En funktion eller en Instance, som klienten ikke kan se (for eksempel alt i ServerStorage), kommer frem som
nil. Med instance streaming slået til har en part, som serveren lige har oprettet, måske endnu ikke nået klienten, når funktionen returnerer. - Et andet script satte callbacket. Kun den sidste tildeling af
OnServerInvokevirker. Søg efter remotens navn i dine scripts.
Hvis kaldet slet ikke returnerer, har intet script endnu sat OnServerInvoke (Roblox holder kald i kø, indtil det sættes), eller callbacket hænger, for eksempel på WaitForChild for noget, der aldrig dukker op.
UnreliableRemoteEvent: til konstante engangsopdateringer
En UnreliableRemoteEvent har de samme metoder og events som en RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent og OnClientEvent. Forskellen er, at Roblox hverken garanterer levering eller rækkefølge. En besked kan blive kasseret uden at blive sendt igen, når:
- den går tabt undervejs eller venter for længe i et overbelastet netværk
- dens data er større end 1000 bytes
- klienten sender oftere end grænsen (det overskydende kasseres i stedet for at blive udskudt)
- der ikke er forbundet nogen handler, når den kommer (den smides væk i stedet for at blive sat i kø)
Beskeder kan også komme i forkert rækkefølge, og deres rækkefølge har intet med dine RemoteEvents eller RemoteFunctions at gøre. Brug den, når kun den nyeste værdi betyder noget, og den næste opdatering kommer om en brøkdel af et sekund: hvor spilleren sigter, positionen af en kosmetisk effekt, en værdi, der ændrer sig hvert frame. Hvis rækkefølgen betyder noget, så læg et løbenummer eller et tidsstempel i hver besked, og ignorér alt, der er ældre end den senest behandlede.
Brug den aldrig til noget, der skal ske præcis én gang, for eksempel et køb, skade, en belønning eller starten af en runde. Og tjek dens argumenter på serveren præcis som ved en RemoteEvent.
Leveringsrækkefølge og hyppighedsgrænser
Robloxs leveringsgarantier gælder én forbindelse i én retning: fra serveren til én klient eller fra én klient til serveren.
- RemoteEvents er pålidelige og ordnede. Tabte beskeder sendes igen, så længe modtageren er forbundet, og beskeder kommer frem i den rækkefølge, du sendte dem, selv på tværs af forskellige RemoteEvents. Hvis serveren sender A, så B, så A til en spiller, får den spiller A, B, A.
- Rækkefølgen gælder det tidspunkt, handlerne starter. Hvis en handler yielder, for eksempel med
task.waitellerWaitForChild, kan den næste besked begynde at blive behandlet, før den første er færdig. - RemoteFunctions og RemoteEvents er ikke ordnet i forhold til hinanden. Hvis din kode afhænger af en streng rækkefølge, så send relaterede beskeder via samme type remote, eller tilføj dit eget løbenummer.
- Ændringer af egenskaber og attributter er ikke ordnet i forhold til remotes. Hvis serveren ændrer en egenskab og derefter kalder en remote, kan klienten se en hvilken som helst af de to først. Lyt efter selve ændringen, for eksempel med
GetPropertyChangedSignal, i stedet for at regne med, at den allerede er kommet. - Handleren findes ikke endnu. RemoteEvent-beskeder står i kø, indtil en handler forbinder. Køen har grænser: når den er fuld, kasseres de næste beskeder, og i Output vises fejlen
Remote event invocation discarded. - En spiller, der går, mister alle beskeder, der endnu ikke er nået frem.
Hyppighedsgrænse. RemoteEvent- og UnreliableRemoteEvent-beskeder fra klient til server er begrænset til cirka 500 forespørgsler i sekundet pr. klient ifølge dokumentationen pr. 30. september 2026. Grænsen er fælles for alle remotes af samme type, så at dele én travl remote op i ti hæver den ikke. Over grænsen behandles RemoteEvent-beskeder senere og beholder rækkefølgen, mens UnreliableRemoteEvent-beskeder kasseres. Motorens grænse forhindrer ikke én spiller i at kalde din remote 50 gange i sekundet, så hver handler, der ændrer noget, har stadig brug for sin egen grænse pr. spiller.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent eller en attribut?
| Brug | Til hvad | Eksempel | Hvad du skal være opmærksom på |
|---|---|---|---|
| RemoteEvent | Beskeder én vej, der skal nå frem, og i rækkefølge | Klient: "mal denne part". Server: "vis denne notifikation" | Tjek hvert argument på serveren |
RemoteFunction med InvokeServer | Klienten skal have et svar, før den kan fortsætte | Indtast en kampagnekode, bekræft et køb | Den, der kalder, venter; hver vej skal returnere en værdi |
RemoteFunction med InvokeClient | Næsten aldrig | Brug FireClient i stedet | En klient, der får en fejl, går eller ikke svarer, ødelægger eller fastlåser kaldet på serveren |
| UnreliableRemoteEvent | Hyppige opdateringer, hvor kun den sidste betyder noget | Sigteretning, kosmetiske effekter | Beskeder går tabt eller skifter rækkefølge; datagrænse på 1000 bytes |
| En attribut eller et value-objekt sat af serveren | Fælles tilstand, der altid skal kunne ses, også af spillere, der kommer senere | Rundetimer, spillets fase, om en dør er åben | Kun serverens ændringer når ud til alle; klienter lytter med GetAttributeChangedSignal eller Changed |
| BindableEvent | Kommunikation mellem scripts på samme side | Ét server-script fortæller et andet, at runden er slut | Går ikke mellem server og klient |
Et fuldt eksempel på, hvordan RemoteFunction og tjek arbejder sammen der, hvor spillere betaler, finder du i guiden sådan laver du en butiks-GUI. Hvad angår rækken om attributter, sætter server-scriptet fra dør-guiden attributten Open på hver dør, hver gang den bevæger sig, så ethvert LocalScript kan reagere på den.
Almindelige fejl og løsninger
De fleste problemer med remotes kan ses i Output-vinduet (åbn det fra menuen Window eller fanen Script). Kig der først, og find derefter dit symptom nedenfor. Guiden til script-fejl gennemgår almindelige fejlbeskeder mere detaljeret.
Infinite yield possible ved WaitForChild for en remote
Scriptet venter på en remote, der aldrig dukker op. Tjek, at navnet og store og små bogstaver passer præcist, og at remoten ligger i ReplicatedStorage og ikke i ServerStorage eller ServerScriptService, som klienterne ikke kan se.
Serveren får de forkerte værdier, forskudt med én
LocalScriptet sendte selve spilleren med, som i remote:FireServer(player, 5). Roblox tilføjer allerede afsenderen som første parameter, så serveren ser (player, player, 5). Kald remote:FireServer(5).
Der sker ingenting, når jeg kalder en remote
Tjek, at hvert kald kommer fra den rigtige side: FireServer og InvokeServer virker kun fra klientkode, og FireClient, FireAllClients og InvokeClient kun fra et server-Script. Et LocalScript kører aldrig i ServerScriptService, ServerStorage eller direkte i Workspace; læg det i StarterPlayerScripts, StarterGui, StarterCharacterScripts eller StarterPack. Søg derefter i Output efter en fejl inde i handleren.
Remote event invocation discarded
Der kom beskeder til en RemoteEvent, der ikke havde en forbundet handler, og køen blev fuld. Som regel går scriptet med handleren ned med en fejl før linjen med :Connect, er slået fra eller hænger og venter på noget, der aldrig bliver indlæst. Forbind handlere tidligt i scriptet.
Det virker for mig, men andre spillere kan ikke se ændringen
Ændringen er lavet på klienten, i et LocalScript eller i en OnClientEvent-handler. Lav den i en OnServerEvent-handler på serveren.
InvokeServer returnerer aldrig
Enten har intet script sat OnServerInvoke (Roblox holder kald i kø, indtil det sættes), eller callbacket hænger på noget, der yielder, for eksempel WaitForChild eller en forespørgsel til et datalager. Tilføj print i starten og slutningen af callbacket for at se, hvor det stopper.
Lav det med RoCode
RoCode kan også sætte det her op, direkte i det place, du har åbent. RoCode er en AI-agent, der arbejder via et plugin til Roblox Studio, så den opretter remotes og scripts i din Explorer i stedet for at give dig kode, som du skal indsætte.
Lad spillerne male parts i mappen Paintable med et klik. Brug en RemoteEvent, og hold tjekkene på serveren: kun parts fra den mappe, højst 30 studs væk og ikke mere end nogle få malinger i sekundet.
- Gennemser som regel først dit place med Search Game og Search Scripts efter en færdig Remotes-mappe eller handler og bruger dine mapper, hvis de findes
- Opretter en RemoteEvent i ReplicatedStorage med Create Instance og skriver server-Scriptet og LocalScriptet med Create Script
- Tjekker før afslutningen kompileringen af hvert script med Check Script inde i Studio. Det fanger kompileringsfejl, ikke logiske fejl: den tjekker ikke typer, kører ikke en linter og kører ikke din kode
- Sender ændringerne i pakker, og hver pakke er et fortrydelsespunkt i Studios historik
Med plugin 3.9 eller nyere kan RoCode køre en kort playtest og læse fejlene, og med plugin 3.9.11 eller nyere kan den styre en testfigur, men den klikker ikke på parts i 3D-vinduet. Tryk selv på Play, og prøv at bryde tjekkene, for eksempel ved at male en part fra den anden ende af kortet. Hvis der opstod en fejl, kan Check Output læse Server- og Client-linjerne fra din seneste playtest. De fleste spilsystemer kommunikerer via sådanne remotes, så du møder dem igen, når du bygger et spil system for system med RoCode. Sådan forbinder RoCode til Studio.
Ofte stillede spørgsmål
Hvad betyder securing the client-server boundary i Roblox?
Sådan hedder en side i Robloxs dokumentation om sikkerhed for remotes, og idéen er enkel: alt, hvad klienten sender via en RemoteEvent eller RemoteFunction, kan komme fra en exploiter, så serveren tjekker det, før den handler. Tjek hvert arguments type, hold tal inden for rimelige grænser, tjek at spilleren lige nu har lov til at gøre det, og begræns, hvor ofte hver spiller kan kalde remoten. Tjeklisten ovenfor viser hvert tjek i kode.
Er det sikkert at bruge RemoteFunction?
InvokeServer er lige så sikker som dit callback på serveren: tjek dets argumenter, og begræns hyppigheden som for enhver RemoteEvent. Den risikable retning er InvokeClient, fordi en klient, der får en fejl, går eller aldrig returnerer en værdi, ødelægger eller fastlåser kaldet på serveren.
Kan exploitere se og kalde mine remotes?
Ja. Alt, hvad der ligger i ReplicatedStorage, når ud til hver klient, og en modificeret klient kan kalde enhver remote med alle mulige argumenter. At omdøbe eller skjule remotes gør dem ikke sikre; det gør tjek af hvert argument på serveren.
Kan én klient sende en RemoteEvent til en anden klient?
Ikke direkte. Send den til serveren, tjek den der, og brug derefter FireClient eller FireAllClients.
Hvor ofte kan man kalde en RemoteEvent?
Robloxs dokumentation angiver en grænse på cirka 500 forespørgsler i sekundet pr. klient for RemoteEvent- og UnreliableRemoteEvent-beskeder sendt til serveren, fælles for alle remotes af samme type. Hold dig et godt stykke under den, og giv hver handler sin egen grænse pr. spiller.
Når FireAllClients spillere, der kommer senere?
Nej. Den når de spillere, der er forbundet i det øjeblik. Til tilstand, som dem, der kommer for sent, har brug for, sætter du en attribut eller et value-objekt på serveren.
Hvad er forskellen på RemoteEvent og BindableEvent?
En RemoteEvent går mellem server og klient. En BindableEvent forbinder scripts på samme side, for eksempel to server-scripts.
Kilder og videre læsning
- Roblox Creator Docs: Remote events and callbacks (på engelsk). FireServer, FireClient, InvokeServer, risici ved InvokeClient, begrænsninger for argumenter og leveringsgarantier
- Roblox Creator Docs: Securing the client-server boundary (på engelsk). Niveauer af tjek, NaN, hyppighedsgrænser, videresendelse fra klient til klient
- Roblox Creator Docs: Security and cheat mitigation tactics (på engelsk). Hvad en modificeret klient kan, og serverens autoritet
- Roblox Creator Docs: Network ownership, movement validation, and physics (på engelsk). Hvorfor klienten styrer sin karakter, og grænserne for afstandstjek
- Roblox Engine API: RemoteEvent (på engelsk). Hyppighedsgrænse og fejlen invocation discarded
- Roblox Engine API: RemoteFunction (på engelsk). OnServerInvoke, advarsler om InvokeClient og forholdsregler med streaming
- Roblox Engine API: UnreliableRemoteEvent (på engelsk). Datagrænse på 1000 bytes
- Roblox Creator Docs: Properties and attributes (på engelsk). Replikeringsrækkefølge mellem ændringer af egenskaber og remote events
Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.