Kort fortalt
En RemoteEvent er et objekt som som regel ligger i ReplicatedStorage og sender meldinger over grensen mellom klient og server. Et LocalScript kaller FireServer, og serveren mottar meldingen i OnServerEvent, der Player-en som sendte den, er lagt til som første argument. Serveren kaller FireClient(player, ...) eller FireAllClients(...), og LocalScripts mottar meldingen i OnClientEvent.
- Bruk bare RemoteFunction (
InvokeServerogOnServerInvoke) når klienten trenger et svar. UnngåInvokeClient: en klient som fikk en feil, gikk ut eller aldri returnerte en verdi, ødelegger kallet på serveren. - Stol aldri på det klienten sender. Sjekk på serveren type, intervall og eierskap for hvert argument, avstanden til spilleren og hvor ofte den kaller remoten.
- Funksjoner, metatabeller og objekter som den andre siden ikke kan se, overlever ikke overføringen. UnreliableRemoteEvent kan miste meldinger eller endre rekkefølgen deres og forkaster alle data over 1000 bytes.
På denne siden
Hvorfor RemoteEvents trengs
Ethvert Roblox-spill kjører som én server pluss én klient for hver spiller. Serveren bestemmer: et nytt objekt eller en endret egenskap når bare ut til alle spillere når serveren lager det. En endring gjort i et LocalScript blir værende på den ene enheten, med få unntak som spillerens egen karakter, der bevegelsen styres av klienten. Derfor må klienten, når et klikk eller et tastetrykk skal endre den felles verdenen, be serveren om det, og når serveren vil at én spillers skjerm skal reagere, må den fortelle klienten det. Hvis skillet mellom Script og LocalScript er nytt for deg, les først Script vs LocalScript vs ModuleScript (på engelsk). Hvis selve scripting er nytt, start med hvordan man skriver skript i Roblox Studio.
For å krysse den grensen gir Roblox deg tre objekter:
- RemoteEvent: en melding én vei. Avsenderen fortsetter med en gang.
- RemoteFunction: en forespørsel som venter på svar. Koden som kaller, tar pause til den andre siden returnerer en verdi.
- UnreliableRemoteEvent: en melding én vei som kan gå tapt eller komme i feil rekkefølge, men belaster nettverket mindre. Passer for data som endrer seg hele tiden.
| Retning | Avsenderen kaller | Mottakeren kobler til | Mottakeren får |
|---|---|---|---|
| Fra klient til server | remote:FireServer(...) i et LocalScript | remote.OnServerEvent i et Script | Player-en som sendte meldingen, og deretter argumentene dine |
| Fra server til én klient | remote:FireClient(player, ...) i et Script | remote.OnClientEvent i et LocalScript | Bare argumentene dine |
| Fra server til alle klienter | remote:FireAllClients(...) i et Script | remote.OnClientEvent i et LocalScript | Bare argumentene dine |
| Klienten spør, serveren svarer | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player og deretter argumentene dine. Den som kalte, får det funksjonen returnerte |
Klienter kan ikke sende meldinger direkte til hverandre. For å sende noe fra én spiller til de andre sender du det til serveren, sjekker det der og lar serveren sende det videre med FireClient eller FireAllClients. Ifølge sikkerhetsanbefalingene fra Roblox fungerer serveren her som dørvakt, ikke som en enkel videresender.
Hvor remotes skal ligge
En remote må ligge et sted der både serveren og klientene kan se den. Det vanlige stedet er ReplicatedStorage; dokumentasjonen fra Roblox nevner at Workspace eller et Tool også kan brukes i noen tilfeller. ServerStorage og ServerScriptService er bare tilgjengelige for serveren, så et LocalScript som venter på en remote derfra, venter for alltid.
- I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og setter inn en Folder. Kall mappen
Remotes. - Hold musen over
Remotes, klikk på +, og sett inn en RemoteEvent. Gi den et navn som beskriver formålet, for eksempelPaintRequest. - Gjenta for hver remote. Denne guiden bruker 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
Skriptene i denne guiden finner remotes med WaitForChild. Den returnerer med en gang hvis remoten allerede er der, og venter hvis den ikke er det ennå, for eksempel når et serverskript lager remotes under spillet. Lag en egen remote for hver type forespørsel: da sjekker hver handler på serveren én form for argumenter, og det er mye lettere å få riktig enn med én remote til alt.
Mønster 1: fra klient til server, med sjekk på serveren
Den vanligste oppgaven: spilleren gjør noe på skjermen sin, og serveren avgjør hva som skjer. Her trykker spilleren Q for å velge en av fire farger og klikker eller trykker på en part for å male den. Alle ser den nye fargen, fordi serveren maler.
Klienten sender to ting: hvilken part og fargens nummer. Selve fargen sender den aldri, og i andre spill skal den på samme måte aldri sende en pris, en belønning eller en skadeverdi. En modifisert klient kan sende hva som helst, så de ekte dataene (her paletten) holder serveren, og argumentene behandler den som en forespørsel som må sjekkes.
- Sett inn en Folder med navnet
Paintablei Workspace, og legg noen ankrede Parts i den. - Sjekk at det finnes en RemoteEvent med navnet
PaintRequestiReplicatedStorage.Remotes. - Sett inn 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")
-- Fargene tilhører serveren. Klienten sender bare et nummer som velger en av 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 mellom karakteren og parten
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- Den første parameteren er alltid spilleren som kalte remoten. Den legges inn av Roblox,
-- så den kan man stole på. Alt etter den kom fra klienten, og det kan man ikke stole på.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Type: en ekte part, ikke en tabell som later som den er en
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Intervall: et heltall fra 1 til 4. NaN og uendelig sorteres også bort 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. Tillatt mål: bare parts i mappen Paintable, ingenting annet i spillet
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Avstand: spillerens karakter må være nær 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. Frekvensgrense: én maling per spiller hvert kvarter 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)
Hver sjekk som ikke bestås, gjør bare return. Det er ingen grunn til å forklare en juksende klient hvorfor den ble avvist.
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 ekte fargene holder serveren
local selectedColour = 1
-- Strålen kan bare treffe parts inne 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 gikk til chatten eller en knapp
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 ber, vi befaler ikke: serveren avgjør om det skal males
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed er true når motoren allerede har håndtert denne inputen, som regel i brukergrensesnittet: et klikk på en knapp eller taster skrevet i et tekstfelt som chatlinjen. Takket være denne sjekken endrer ikke bokstaven Q, skrevet i en melding, fargen.
Mønster 2: fra server til én klient
Serveren sender en melding til én spiller med FireClient. Det første argumentet er Player-en den er adressert til, og handleren på klienten får bare argumentene etter den. Bruk det til alt personlig: et varsel, et belønningsvindu, en lyd bare den spilleren skal høre. Cutscene-guiden er et større gjennomgått eksempel: serveren avgjør når spilleren ser en cutscene, og sender bildene til den ene spilleren med FireClient, mens spillerens enhet flytter kameraet.
Dette paret med skript viser en velkomst når en spiller kommer inn. LocalScriptet bygger et lite banner selv, så du trenger ikke sette opp en GUI.
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 argumentet velger hvilken klient som får meldingen. 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 inn før dette skriptet kobler til, så vi ønsker alle som allerede er her, velkommen
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 lite banner øverst på skjermen, bygd 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 det ingen player-parameter: serveren har allerede valgt hvem som får meldingen
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 av en nyere melding
label.Visible = false
end
end)
end)
Serveren sender meldingen ved PlayerAdded, og det kan skje før dette LocalScriptet kobler til handleren sin. Det er greit: Roblox setter RemoteEvent-meldinger som kom før handleren fantes, i kø og leverer dem i rekkefølge så snart handleren kobler til.
Klienten trenger ikke beskytte seg mot serveren: bare serverkode kan utløse OnClientEvent. Annotasjonen message: string er for typekontroll; det er ikke en sjekk under kjøring.
Mønster 3: fra server til alle klienter
FireAllClients sender den samme meldingen til hver tilkoblet spiller. Den har ikke noe Player-argument, og hver klient mottar meldingen i den samme OnClientEvent som før, så skriptet NotifyClient fra mønster 2 viser den allerede.
Dette Scriptet sier fra til alle når en spiller rører mållinjen for første gang. Legg til en ankret Part med navnet FinishLine i Workspace, og legg deretter til 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 kunngjort
end
finished[player] = true
-- Hver tilkoblet klient kjører OnClientEvent-handleren sin med denne teksten
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
En exploiter kan utløse Touched for karakteren sin fra hvilken som helst avstand, men for en kunngjøring som vises én gang per spiller, er det harmløst. Hvis du senere gir en belønning for å nå målet, legg til sjekker på serveren før utbetalingen, for eksempel en minimumstid fra rundestart.
FireAllClients når bare spillerne som er tilkoblet i det øyeblikket. Den som kommer inn et sekund senere, ser ikke meldingen. Det passer for enkeltstående øyeblikk som en kunngjøring, en eksplosjonseffekt eller en lyd, men ikke for tilstand som en rundetimer eller spillets nåværende fase. For tilstand setter du et attributt på serveren, for eksempel ReplicatedStorage:SetAttribute("TimeLeft", 30), og leser det på klienten med GetAttribute og GetAttributeChangedSignal("TimeLeft"). Attributter replikeres til hver klient, også til spillere som kommer senere.
RemoteFunction: når klienten trenger et svar
En RemoteEvent fungerer etter prinsippet "send og glem". En RemoteFunction får den som kaller, til å vente: InvokeServer setter koden som kalte den, på pause til serverens funksjon OnServerInvoke returnerer en verdi, og gir deretter det den returnerte. Bruk den når klienten ikke kan fortsette uten et svar, for eksempel "var denne koden riktig?". Når det ikke trengs noe svar, anbefaler Roblox en RemoteEvent, fordi den ikke venter.
Eksempel: et felt der spillerne skriver inn en kampanjekode. Serveren holder kodene, sjekker teksten og returnerer to verdier: om det virket, og meldingen som skal vises.
- Sett inn en RemoteFunction med navnet
RedeemCodeiReplicatedStorage.Remotes. - Sett inn en ScreenGui med navnet
CodeGuii StarterGui og inni den en TextBox med navnetCodeBox. Velg størrelse og plassering etter smak. - Legg til Scriptet nedenfor i ServerScriptService og LocalScriptet inne i
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Kodene bor på serveren, der ingen spiller kan lese 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 } = {}
-- Tilordne med =. OnServerInvoke er en callback, ikke et event man kobler 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 legger til statistikken Coins fra guiden om leaderboards. Brukte koder huskes bare til spilleren går, så i denne formen kan en spiller komme inn igjen og skrive inn den samme koden på nytt. Hvis myntene lagres, blir det gratis mynter ved hvert nye besøk: før du bruker dette i et live spill, lagre hver spillers brukte koder sammen med spillerens lagrede 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 setter denne funksjonen på pause til serverens callback returnerer en verdi.
-- pcall hindrer at LocalScriptet stopper hvis kallet feilet.
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 nøyaktig én callback på serveren. Hvis to skript setter OnServerInvoke på den samme RemoteFunction, virker bare det siste.
Hvorfor InvokeClient er farlig
En RemoteFunction virker også den andre veien, med InvokeClient på serveren og OnClientInvoke på klienten. Dokumentasjonen fra Roblox nevner tre alvorlige risikoer:
- Hvis klientens callback gir en feil, gir serveren også en feil.
- Hvis spilleren går under kallet, gir
InvokeClienten feil. - Hvis klienten aldri returnerer en verdi, venter serverskriptet for alltid.
En modifisert klient styrer sin egen callback, så en juksemaker kan med vilje fremkalle det tredje tilfellet og holde den servertråden så lenge den vil. For å oppdatere en spillers skjerm bruker du FireClient. Hvis serveren virkelig trenger informasjon fra klienten, send en RemoteEvent, la klienten svare via en annen RemoteEvent, og behandle et manglende svar som et normalt tilfelle på serveren.
Sjekk hvert argument på serveren
En exploiter kan kalle enhver RemoteEvent eller RemoteFunction så mange ganger den vil, og med alle mulige argumenter. Det eneste den ikke kan forfalske, er den første parameteren: Roblox legger selv inn Player-en som sendte meldingen. Alt som kommer etter, må sjekkes før serveren handler. Det nytter ikke å skjule remoten eller sjekke i et LocalScript, fordi juksemakeren styrer sin egen klient.
| Sjekk | Spørsmålet serveren stiller | Eksempel |
|---|---|---|
| Type | Er det typen jeg forventer? En Instance og ikke en tabell bygd for å ligne en? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Intervall | Er tallet endelig og innenfor de tillatte grensene? Har teksten en rimelig lengde? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Eierskap | Eier spilleren tingen, har den nok penger, har den rett til å handle med dette objektet? | Tingen er i spillerens inventar; parten ligger inne i Paintable |
| Avstand | Er spillerens karakter nær nok i serverens kopi av verdenen? Gi litt margin for lag. | Høyst 30 studs fra parten |
| Frekvens | Sender denne spilleren for ofte? | Cooldown per spiller eller en grense med oppsparte kall |
NaN fortjener en egen advarsel. Det er et tall, så type(x) == "number" består, men enhver sammenligning med det gir false, og en sjekk som x < 0 or x > 100 slipper det gjennom. math.isfinite(x) avviser NaN og begge uendelighetene.
Husk grensen for avstandssjekken. Hver klient styrer fysikken for karakteren sin, så en exploiter kan flytte karakteren bort til målet før kallet. Sjekken stopper likevel det enkleste misbruket, der man fra ett sted handler over hele kartet. Hold målparts ankret: sikkerhetsdokumentasjonen fra Roblox nevner at en exploiter kan få network ownership over ikke-ankrede parts i nærheten og trekke dem nærmere, og det kommer rundt avstandssjekken.
Her er de samme sjekkene som et ModuleScript du kan bruke i hver remote-handler.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Et ekte tall mellom min og max. Avviser NaN og uendelig, som består
-- den vanlige sjekken 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 heltall mellom min og max, for antall, indekser og tellere
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 lengdegrense. utf8.len returnerer nil for ugyldig UTF-8, som
-- datalagre avviser.
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 av den forventede klassen inne i en container du har tillatt.
-- En tabell bygd for å ligne en Instance består ikke typeof-sjekken.
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øyst 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
-- Frekvensgrense per spiller. Hver spiller kan gjøre `burst` kall på én gang og
-- får `perSecond` kall tilbake hvert sekund. Returnerer en funksjon som kalles
-- før arbeidet: den svarer true (tillatt) 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 aldri ut til klientene, så ingen kan lese sjekkene dine.
Og her er handleren fra mønster 1, skrevet om med den. Erstatt innholdet i PaintServer:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" har bare betydning for den strenge typekontrollen i Luau; under kjøring endrer 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, deretter 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)
Begrenseren sletter spillerens oppføring når den går, så tabellen vokser ikke så lenge serveren kjører.
I våpen er disse sjekkene viktigst: la aldri klienten melde hvem som ble truffet. Remoten fra sverd-guiden har ingen argumenter i det hele tatt, og serveren finner målene selv. Våpen-guiden sender bare siktepunktet, som serveren sjekker for type, NaN og avstand før den sender sin egen stråle.
Menyer følger samme regel: send valget, ikke resultatet. I guiden om NPC-dialoger sender klienten bare nummeret på knappen som ble trykket, og serveren ser selv hva det svaret gir. Menyen fra teleport-guiden sender navnet på stedet, ikke en posisjon, og serveren finner stedet i mappen sin og sjekker hvor mange Wins det krever.
Hva du kan og ikke kan sende
Du kan sende tall, strenger, boolske verdier, Roblox-typer som Vector3, CFrame, Color3 og Enum-elementer, Instances som begge sider kan se, og tabeller av alt dette. Noen verdier endres eller forsvinner underveis:
| Du sender | Hva som skjer |
|---|---|
| En funksjon | Den andre siden får nil |
| En tabell med en metatabell | Metatabellen går tapt sammen med alt tabellen bare hadde via den |
| En tabell der tall- og strengnøkler er blandet | Roblox fraråder det: send et rent array eller en ren ordbok |
En tabell med nil-verdier inni | Unngå det: Roblox fraråder nil på enhver indeks |
| En tabell med nøkler av typen Instance, userdata eller function | Slike nøkler blir til strenger |
| En Instance som mottakeren ikke kan se, for eksempel fra ServerStorage eller laget i et LocalScript | Den andre siden får nil |
| Enhver tabell | Mottakeren får en kopi, ikke den samme tabellen |
En god vane: send identifikatorer, ikke objekter eller verdier. Et navn på en ting, et nummer på et valg, en part som serveren kan finne og sjekke. Deretter jobber serveren med sine egne data.
Hvorfor RemoteFunction returnerer nil
Hvis InvokeServer gir deg nil, gå gjennom disse punktene i rekkefølge:
- En vei uten returverdi. Hver utgang fra
OnServerInvokemå returnere noe. En tomreturni en tidlig sjekk senderniltilbake. - return inne i en nestet funksjon.
returninne ipcall(function() ... end), en:Connect-handler ellertask.spawnforlater bare den indre funksjonen. Lagre resultatet, for eksempellocal ok, data = pcall(...), og returner deretterdatafra selve callbacken. - En verdi som ikke kan krysse grensen. En funksjon eller en Instance som klienten ikke kan se (for eksempel alt i ServerStorage), kommer frem som
nil. Med instance streaming slått på har en part som serveren nettopp laget, kanskje ikke nådd klienten ennå når funksjonen returnerer. - Et annet skript satte callbacken. Bare den siste tilordningen av
OnServerInvokevirker. Søk etter navnet på remoten i skriptene dine.
Hvis kallet ikke returnerer i det hele tatt, har ingen skript satt OnServerInvoke ennå (Roblox holder kall i kø til den settes), eller callbacken henger, for eksempel på WaitForChild for noe som aldri dukker opp.
UnreliableRemoteEvent: for konstante engangsoppdateringer
En UnreliableRemoteEvent har de samme metodene og eventene som en RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent og OnClientEvent. Forskjellen er at Roblox verken garanterer levering eller rekkefølge. En melding kan bli forkastet uten å bli sendt på nytt når:
- den går tapt underveis eller venter for lenge i et overbelastet nettverk
- dataene er større enn 1000 bytes
- klienten sender oftere enn grensen (det overskytende forkastes i stedet for å bli utsatt)
- det ikke er koblet til noen handler når den kommer (den kastes i stedet for å bli satt i kø)
Meldinger kan også komme i feil rekkefølge, og rekkefølgen deres har ingenting med RemoteEvents eller RemoteFunctions å gjøre. Bruk den når bare den nyeste verdien betyr noe og neste oppdatering kommer om en brøkdel av et sekund: hvor spilleren sikter, posisjonen til en kosmetisk effekt, en verdi som endrer seg hver frame. Hvis rekkefølgen betyr noe, legg et løpenummer eller et tidsstempel i hver melding, og ignorer alt som er eldre enn det sist behandlede.
Bruk den aldri til noe som skal skje nøyaktig én gang, for eksempel et kjøp, skade, en belønning eller starten på en runde. Og sjekk argumentene på serveren akkurat som ved en RemoteEvent.
Leveringsrekkefølge og frekvensgrenser
Leveringsgarantiene fra Roblox gjelder én tilkobling i én retning: fra serveren til én klient eller fra én klient til serveren.
- RemoteEvents er pålitelige og ordnede. Tapte meldinger sendes på nytt så lenge mottakeren er tilkoblet, og meldinger kommer frem i rekkefølgen du sendte dem, selv på tvers av ulike RemoteEvents. Hvis serveren sender A, så B, så A til en spiller, får den spilleren A, B, A.
- Rekkefølgen gjelder tidspunktet handlerne starter. Hvis en handler yielder, for eksempel med
task.waitellerWaitForChild, kan neste melding begynne å bli behandlet før den første er ferdig. - RemoteFunctions og RemoteEvents er ikke ordnet i forhold til hverandre. Hvis koden din er avhengig av en streng rekkefølge, send relaterte meldinger via samme type remote, eller legg til ditt eget løpenummer.
- Endringer av egenskaper og attributter er ikke ordnet i forhold til remotes. Hvis serveren endrer en egenskap og deretter kaller en remote, kan klienten se hvilken som helst av de to først. Lytt etter selve endringen, for eksempel med
GetPropertyChangedSignal, i stedet for å regne med at den allerede har kommet. - Handleren finnes ikke ennå. RemoteEvent-meldinger står i kø til en handler kobler til. Køen har grenser: når den er full, forkastes de neste meldingene, og i Output vises feilen
Remote event invocation discarded. - En spiller som går, mister alle meldinger som ikke har kommet frem ennå.
Frekvensgrense. RemoteEvent- og UnreliableRemoteEvent-meldinger fra klient til server er begrenset til omtrent 500 forespørsler i sekundet per klient ifølge dokumentasjonen per 30. september 2026. Grensen er felles for alle remotes av samme type, så å dele én travel remote i ti hever den ikke. Over grensen behandles RemoteEvent-meldinger senere og beholder rekkefølgen, mens UnreliableRemoteEvent-meldinger forkastes. Motorens grense hindrer ikke én spiller i å kalle remoten din 50 ganger i sekundet, så hver handler som endrer noe, trenger fortsatt sin egen grense per spiller.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent eller et attributt?
| Bruk | Til hva | Eksempel | Hva du må være oppmerksom på |
|---|---|---|---|
| RemoteEvent | Meldinger én vei som må komme frem, og i rekkefølge | Klient: "mal denne parten". Server: "vis dette varselet" | Sjekk hvert argument på serveren |
RemoteFunction med InvokeServer | Klienten må ha et svar før den kan fortsette | Skriv inn en kampanjekode, bekreft et kjøp | Den som kaller, venter; hver vei må returnere en verdi |
RemoteFunction med InvokeClient | Nesten aldri | Bruk FireClient i stedet | En klient som får en feil, går eller ikke svarer, ødelegger eller låser kallet på serveren |
| UnreliableRemoteEvent | Hyppige oppdateringer der bare den siste betyr noe | Sikteretning, kosmetiske effekter | Meldinger går tapt eller bytter rekkefølge; datagrense på 1000 bytes |
| Et attributt eller et value-objekt satt av serveren | Felles tilstand som alltid skal kunne ses, også av spillere som kommer senere | Rundetimer, spillets fase, om en dør er åpen | Bare serverens endringer når ut til alle; klienter lytter med GetAttributeChangedSignal eller Changed |
| BindableEvent | Kommunikasjon mellom skript på samme side | Ett serverskript forteller et annet at runden er over | Går ikke mellom server og klient |
Et fullstendig eksempel på hvordan RemoteFunction og sjekker jobber sammen der spillere betaler, finner du i guiden slik lager du en butikk-GUI. Når det gjelder raden om attributter, setter serverskriptet fra dør-guiden attributtet Open på hver dør hver gang den beveger seg, slik at ethvert LocalScript kan reagere på det.
Vanlige feil og løsninger
De fleste problemer med remotes kan ses i Output-vinduet (åpne det fra menyen Window eller fanen Script). Se der først, og finn deretter symptomet ditt nedenfor. Guiden om skriptfeil går gjennom vanlige feilmeldinger mer i detalj.
Infinite yield possible ved WaitForChild for en remote
Skriptet venter på en remote som aldri dukker opp. Sjekk at navnet og store og små bokstaver stemmer nøyaktig, og at remoten ligger i ReplicatedStorage og ikke i ServerStorage eller ServerScriptService, som klientene ikke kan se.
Serveren får feil verdier, forskjøvet med én
LocalScriptet sendte med selve spilleren, som i remote:FireServer(player, 5). Roblox legger allerede til avsenderen som første parameter, så serveren ser (player, player, 5). Kall remote:FireServer(5).
Ingenting skjer når jeg kaller en remote
Sjekk at hvert kall kommer fra riktig side: FireServer og InvokeServer virker bare fra klientkode, og FireClient, FireAllClients og InvokeClient bare fra et server-Script. Et LocalScript kjører aldri i ServerScriptService, ServerStorage eller direkte i Workspace; legg det i StarterPlayerScripts, StarterGui, StarterCharacterScripts eller StarterPack. Søk deretter i Output etter en feil inne i handleren.
Remote event invocation discarded
Det kom meldinger til en RemoteEvent som ikke hadde noen tilkoblet handler, og køen ble full. Som regel krasjer skriptet med handleren med en feil før linjen med :Connect, er slått av eller henger og venter på noe som aldri blir lastet. Koble til handlere tidlig i skriptet.
Det virker for meg, men andre spillere ser ikke endringen
Endringen er gjort på klienten, i et LocalScript eller i en OnClientEvent-handler. Gjør den i en OnServerEvent-handler på serveren.
InvokeServer returnerer aldri
Enten har ingen skript satt OnServerInvoke (Roblox holder kall i kø til den settes), eller callbacken henger på noe som yielder, for eksempel WaitForChild eller en forespørsel til et datalager. Legg til print i starten og slutten av callbacken for å se hvor den stopper.
Lag det med RoCode
RoCode kan også sette opp dette, direkte i placen du har åpen. RoCode er en AI-agent som jobber via en plugin for Roblox Studio, så den lager remotes og skript i Explorer hos deg i stedet for å gi deg kode du må lime inn.
La spillerne male parts i mappen Paintable med et klikk. Bruk en RemoteEvent, og hold sjekkene på serveren: bare parts fra den mappen, høyst 30 studs unna og ikke mer enn noen få malinger i sekundet.
- Går som regel først gjennom placen din med Search Game og Search Scripts etter en ferdig Remotes-mappe eller handler, og bruker mappene dine hvis de finnes
- Lager en RemoteEvent i ReplicatedStorage med Create Instance og skriver server-Scriptet og LocalScriptet med Create Script
- Sjekker før den avslutter kompileringen av hvert skript med Check Script inne i Studio. Det fanger kompileringsfeil, ikke logiske feil: den sjekker ikke typer, kjører ikke en linter og kjører ikke koden din
- Sender endringene i pakker, og hver pakke er et angrepunkt i historikken i Studio
Med plugin 3.9 eller nyere kan RoCode kjøre en kort playtest og lese feilene, og med plugin 3.9.11 eller nyere kan den styre en testfigur, men den klikker ikke på parts i 3D-vinduet. Trykk Play selv, og prøv å bryte sjekkene, for eksempel ved å male en part fra den andre enden av kartet. Hvis det oppsto en feil, kan Check Output lese Server- og Client-linjene fra den siste playtesten din. De fleste spillsystemer kommuniserer via slike remotes, så du møter dem igjen når du bygger et spill system for system med RoCode. Slik kobler RoCode seg til Studio.
Ofte stilte spørsmål
Hva betyr securing the client-server boundary i Roblox?
Det er navnet på en side i dokumentasjonen fra Roblox om sikkerhet for remotes, og ideen er enkel: alt klienten sender via en RemoteEvent eller RemoteFunction, kan komme fra en exploiter, så serveren sjekker det før den handler. Sjekk typen til hvert argument, hold tall innenfor rimelige grenser, sjekk at spilleren akkurat nå har lov til å gjøre det, og begrens hvor ofte hver spiller kan kalle remoten. Sjekklisten ovenfor viser hver sjekk i kode.
Er det trygt å bruke RemoteFunction?
InvokeServer er like trygg som callbacken din på serveren: sjekk argumentene, og begrens frekvensen som for enhver RemoteEvent. Den risikable retningen er InvokeClient, fordi en klient som får en feil, går eller aldri returnerer en verdi, ødelegger eller låser kallet på serveren.
Kan exploitere se og kalle remotene mine?
Ja. Alt som ligger i ReplicatedStorage, når ut til hver klient, og en modifisert klient kan kalle enhver remote med alle mulige argumenter. Å gi remotes nye navn eller skjule dem gjør dem ikke trygge; det gjør sjekk av hvert argument på serveren.
Kan én klient sende en RemoteEvent til en annen klient?
Ikke direkte. Send den til serveren, sjekk den der, og bruk deretter FireClient eller FireAllClients.
Hvor ofte kan man kalle en RemoteEvent?
Dokumentasjonen fra Roblox oppgir en grense på omtrent 500 forespørsler i sekundet per klient for RemoteEvent- og UnreliableRemoteEvent-meldinger sendt til serveren, felles for alle remotes av samme type. Hold deg godt under den, og gi hver handler sin egen grense per spiller.
Når FireAllClients spillere som kommer senere?
Nei. Den når spillerne som er tilkoblet i det øyeblikket. For tilstand som de som kommer for sent, trenger, setter du et attributt eller et value-objekt på serveren.
Hva er forskjellen på RemoteEvent og BindableEvent?
En RemoteEvent går mellom server og klient. En BindableEvent kobler sammen skript på samme side, for eksempel to serverskript.
Kilder og videre lesing
- Roblox Creator Docs: Remote events and callbacks (på engelsk). FireServer, FireClient, InvokeServer, risikoer ved InvokeClient, begrensninger for argumenter og leveringsgarantier
- Roblox Creator Docs: Securing the client-server boundary (på engelsk). Nivåer av sjekker, NaN, frekvensgrenser, videresending fra klient til klient
- Roblox Creator Docs: Security and cheat mitigation tactics (på engelsk). Hva en modifisert klient kan gjøre, og serverens autoritet
- Roblox Creator Docs: Network ownership, movement validation, and physics (på engelsk). Hvorfor klienten styrer karakteren sin, og grensene for avstandssjekker
- Roblox Engine API: RemoteEvent (på engelsk). Frekvensgrense og feilen invocation discarded
- Roblox Engine API: RemoteFunction (på engelsk). OnServerInvoke, advarsler om InvokeClient og forholdsregler med streaming
- Roblox Engine API: UnreliableRemoteEvent (på engelsk). Datagrense på 1000 bytes
- Roblox Creator Docs: Properties and attributes (på engelsk). Replikeringsrekkefølge mellom endringer av egenskaper og remote events
Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.