I korthet
RemoteEvent är ett objekt som oftast ligger i ReplicatedStorage och skickar meddelanden över gränsen mellan klienten och servern. Ett LocalScript anropar FireServer, och servern tar emot meddelandet i OnServerEvent, där den Player som skickade det har lagts till som första argument. Servern anropar FireClient(player, ...) eller FireAllClients(...), och LocalScripts tar emot meddelandet i OnClientEvent.
- Använd RemoteFunction (
InvokeServerochOnServerInvoke) bara när klienten behöver ett svar. UndvikInvokeClient: en klient som får ett fel, lämnar spelet eller aldrig returnerar något får anropet på servern att haka upp sig. - Lita aldrig på det klienten skickar. Kontrollera på servern typen, intervallet och ägarskapet för varje argument, avståndet till spelaren och hur ofta den anropar remoten.
- Funktioner, metatabeller och objekt som den andra sidan inte ser överlever inte överföringen. UnreliableRemoteEvent kan tappa meddelanden eller ändra deras ordning och kastar all data som är större än 1000 byte.
På den här sidan
- Varför remotes behövs
- Konfigurera remotes
- 1. Från klienten till servern
- 2. Från servern till klienten
- 3. Från servern till alla
- RemoteFunction
- Checklista för kontroller
- Vad som inte går att skicka
- Returnerar nil?
- UnreliableRemoteEvent
- Ordning och gränser
- Vad du ska välja
- Common errors
- Med RoCode
- Vanliga frågor
- Källor och vidare läsning
Varför RemoteEvent behövs
Varje Roblox-spel körs som en server plus en klient för varje spelare. Servern bestämmer här: ett nytt objekt eller en ändrad egenskap når alla spelare bara när servern gör det. En ändring som görs i ett LocalScript stannar på en enhet, med några få undantag som spelarens egen karaktär, vars rörelser styrs av spelarens klient. Därför måste klienten be servern när ett klick eller en knapptryckning ska ändra den gemensamma världen, och när servern vill att en enskild spelares skärm ska reagera måste den meddela klienten. Om uppdelningen i Script och LocalScript är ny för dig, läs först Script vs LocalScript vs ModuleScript (på engelska). Om skriptning i sig är nytt, börja med hur du skriver skript i Roblox Studio.
För att korsa den gränsen ger Roblox dig tre objekt:
- RemoteEvent: ett meddelande åt ett håll. Avsändaren fortsätter direkt.
- RemoteFunction: en förfrågan som väntar på svar. Koden som anropade står pausad tills den andra sidan returnerar ett värde.
- UnreliableRemoteEvent: ett meddelande åt ett håll som kan gå förlorat eller komma i fel ordning, men som belastar nätverket mindre. Passar för data som ändras hela tiden.
| Riktning | Avsändaren anropar | Mottagaren ansluter till | Mottagaren får |
|---|---|---|---|
| Från klienten till servern | remote:FireServer(...) i ett LocalScript | remote.OnServerEvent i ett Script | Den Player som skickade meddelandet, sedan dina argument |
| Från servern till en klient | remote:FireClient(player, ...) i ett Script | remote.OnClientEvent i ett LocalScript | Bara dina argument |
| Från servern till alla klienter | remote:FireAllClients(...) i ett Script | remote.OnClientEvent i ett LocalScript | Bara dina argument |
| Klienten frågar, servern svarar | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player, sedan dina argument. Den som anropade får det funktionen returnerade |
Klienter kan inte skicka meddelanden direkt till varandra. För att skicka något från en spelare till de andra, skicka det till servern, kontrollera det där och låt servern skicka det vidare med FireClient eller FireAllClients. Enligt Roblox rekommendationer för säkerhet fungerar servern här som en grindvakt, inte som en enkel relästation.
Var du förvarar remotes
En remote måste ligga där både servern och klienterna ser den. Den vanliga platsen är ReplicatedStorage; Roblox dokumentation nämner att Workspace eller ett Tool också fungerar i vissa fall. ServerStorage och ServerScriptService är bara tillgängliga för servern, så ett LocalScript som väntar på en remote där kommer att vänta för evigt.
- I Explorer, håll muspekaren över ReplicatedStorage, klicka på knappen + och infoga en Folder. Döp mappen till
Remotes. - Håll muspekaren över
Remotes, klicka på + och infoga ett RemoteEvent. Byt namn på det så att namnet beskriver syftet, till exempelPaintRequest. - Upprepa för varje remote. Den här guiden använder två RemoteEvent (
PaintRequestochNotify) och en 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
Skripten i den här guiden hittar remotes med WaitForChild. Den returnerar direkt om remoten redan finns och väntar om den inte finns än, till exempel när ett serverskript skapar remotes under spelets gång. Skapa en separat remote för varje typ av förfrågan: då kontrollerar varje hanterare på servern en enda form av argument, och det är mycket lättare att göra rätt än med en remote för allt.
Mönster 1: från klienten till servern, med kontroll på servern
Den vanligaste uppgiften: spelaren gör något på sin skärm, och servern bestämmer vad som händer. Här trycker spelaren på Q för att välja en av fyra färger och klickar eller trycker på en part för att måla den. Alla ser den nya färgen, eftersom det är servern som målar.
Klienten skickar två saker: vilken part och färgens nummer. Själva färgen skickar den aldrig, och i andra spel ska den på samma sätt aldrig skicka ett pris, en belöning eller en skademängd. En modifierad klient kan skicka vad som helst, så den riktiga datan (här paletten) förvaras av servern, och argumenten behandlar den som en förfrågan som måste kontrolleras.
- I Workspace, infoga en Folder som heter
Paintableoch lägg några förankrade (anchored) Part i den. - Kontrollera att
ReplicatedStorage.Remotesinnehåller ett RemoteEvent som heterPaintRequest. - Infoga ett Script som heter
PaintServeri ServerScriptService och ett LocalScript som heterPaintClienti StarterPlayer, StarterPlayerScripts, med koden nedan.
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")
-- Färgerna tillhör servern. Klienten skickar bara ett nummer som väljer 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 mellan karaktären och parten
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- Den första parametern är alltid spelaren som anropade remoten. Den fylls i av Roblox,
-- så den kan du lita på. Allt efter den kom från klienten, och det kan du inte lita på.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Typ: en riktig part, inte en tabell som låtsas vara en
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Intervall: ett heltal från 1 till 4. NaN och oändlighet sorteras också bort här.
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. Tillåtet mål: bara parts i mappen Paintable, inget annat i spelet
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Avstånd: spelarens karaktär måste vara nära 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. Frekvensgräns: en målning per spelare var fjärdedels 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)
Varje kontroll som inte går igenom gör bara return. Det finns ingen anledning att förklara för en fuskande klient varför den nekades.
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 riktiga färgerna förvaras av servern
local selectedColour = 1
-- Strålen kan bara träffa parts inuti 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 -- tangenten eller klicket gick till 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 beordrar inte: om parten ska målas bestämmer servern
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed är true när motorn redan har hanterat inmatningen, oftast i gränssnittet: ett klick på en knapp eller tangenter som skrivs i ett textfält som chattraden. Tack vare den kontrollen ändrar ett Q som skrivs i ett meddelande inte färgen.
Mönster 2: från servern till en klient
Servern skickar ett meddelande till en spelare med FireClient. Det första argumentet är den Player som det är adresserat till, och hanteraren på klienten får bara argumenten efter det. Använd det för allt personligt: en avisering, ett belöningsfönster, ett ljud som bara den spelaren ska höra. Guiden om cutscenes är ett större genomgånget exempel: servern bestämmer när spelaren ska se en cutscene och skickar dess bilder till just den spelaren med FireClient, medan kameran styrs av spelarens enhet.
Det här skriptparet visar en hälsning när en spelare går med. LocalScript bygger själv en liten banner, så du behöver inte ställa in något 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örsta argumentet väljer vilken klient som får meddelandet. Ingen annan ser det.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- I Studio kan du gå med innan det här skriptet ansluter, så vi hälsar på alla som redan är här
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
-- En liten banner överst på skärmen, byggd i kod
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
-- Här finns ingen player-parameter: servern har redan valt vem som får meddelandet
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 -- döljer om det inte har ersatts av ett nyare meddelande
label.Visible = false
end
end)
end)
Servern skickar meddelandet vid PlayerAdded, och det kan hända innan detta LocalScript har anslutit sin hanterare. Det gör inget: Roblox köar RemoteEvent-meddelanden som kommer innan en hanterare finns och levererar dem i ordning så snart hanteraren ansluts.
Klienten behöver inte skydda sig mot servern: bara kod på servern kan utlösa OnClientEvent. Annoteringen message: string är till för typkontrollen; det är ingen kontroll under körning.
Mönster 3: från servern till alla klienter
FireAllClients skickar samma meddelande till varje ansluten spelare. Det har inget Player-argument, och varje klient tar emot meddelandet i samma OnClientEvent som tidigare, så skriptet NotifyClient från mönster 2 visar det redan.
Det här Script meddelar alla när en spelare rör vid mållinjen för första gången. Lägg till en förankrad Part som heter FinishLine i Workspace och lägg sedan till Script 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 -- inte en spelare eller redan tillkännagiven
end
finished[player] = true
-- Varje ansluten klient kör sin egen OnClientEvent-hanterare med den här texten
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
En exploiter kan utlösa Touched för sin karaktär från vilket avstånd som helst, men för ett meddelande som visas en gång per spelare är det ofarligt. Om du senare delar ut en belöning för att gå i mål, lägg till kontroller på servern innan den delas ut, till exempel en minsta tid sedan rundan började.
FireAllClients når bara de spelare som är anslutna i just det ögonblicket. Den som går med en sekund senare ser aldrig meddelandet. Det passar för engångsögonblick som ett tillkännagivande, en explosionseffekt eller ett ljud, men inte för tillstånd som en rundtimer eller spelets nuvarande fas. För tillstånd, sätt ett attribut på servern, till exempel ReplicatedStorage:SetAttribute("TimeLeft", 30), och läs det på klienten med GetAttribute och GetAttributeChangedSignal("TimeLeft"). Attribut replikeras till varje klient, även till spelare som går med senare.
RemoteFunction: när klienten behöver ett svar
RemoteEvent fungerar enligt principen "skicka och glöm". RemoteFunction får den som anropar att vänta: InvokeServer pausar koden som anropade den tills serverfunktionen OnServerInvoke returnerar ett värde, och lämnar sedan tillbaka det den returnerade. Använd den när klienten inte kan fortsätta utan svar, till exempel "var den här koden rätt?". När inget svar behövs rekommenderar Roblox RemoteEvent, eftersom det inte väntar.
Exempel: ett fält där spelare skriver in en kampanjkod. Servern förvarar koderna, kontrollerar texten och returnerar två värden: om det fungerade och ett meddelande att visa.
- I
ReplicatedStorage.Remotes, infoga en RemoteFunction som heterRedeemCode. - I StarterGui, infoga en ScreenGui som heter
CodeGuioch inuti den en TextBox som heterCodeBox. Storlek och placering väljer du själv. - Lägg till Script nedan i ServerScriptService och LocalScript inuti
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Koderna finns på servern, där ingen spelare kan läsa 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 } = {}
-- Vi tilldelar med =. OnServerInvoke är en callback, inte ett event som man gör Connect på.
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 till på statistiken Coins från guiden om topplistan. Använda koder kommer bara ihåg tills spelaren lämnar, så i den här formen kan en spelare gå med igen och skriva in samma kod en gång till. Om mynten sparas blir det gratis mynt vid varje återanslutning: innan du använder detta i ett publicerat spel, spara varje spelares använda koder tillsammans med spelarens sparade data i en 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 pausar den här funktionen tills serverns callback returnerar ett värde.
-- pcall hindrar LocalScript från att stanna om anropet misslyckas.
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 exakt en callback på servern. Om två skript sätter OnServerInvoke på samma RemoteFunction gäller bara det sista.
Varför InvokeClient är farligt
RemoteFunction fungerar också åt andra hållet, med InvokeClient på servern och OnClientInvoke på klienten. Roblox dokumentation listar tre allvarliga risker:
- Om klientens callback ger ett fel ger servern också ett fel.
- Om spelaren lämnar under anropet ger
InvokeClientett fel. - Om klienten aldrig returnerar ett värde väntar serverskriptet för evigt.
En modifierad klient styr sin egen callback, så en fuskare kan medvetet framkalla det tredje fallet och hålla den servertråden så länge den vill. För att uppdatera en spelares skärm, använd FireClient. Om servern verkligen behöver information från klienten, skicka ett RemoteEvent, låt klienten svara via ett annat RemoteEvent och behandla ett uteblivet svar som ett normalt fall på servern.
Kontrollera varje argument på servern
En exploiter kan anropa vilket RemoteEvent eller vilken RemoteFunction som helst hur många gånger som helst och med vilka argument som helst. Det enda den inte kan förfalska är den första parametern: Roblox fyller själv i den Player som skickade meddelandet. Allt som kommer efter måste kontrolleras innan servern agerar. Att gömma remoten eller kontrollera i ett LocalScript är meningslöst, eftersom fuskaren styr sin egen klient.
| Kontroll | Frågan servern ställer | Exempel |
|---|---|---|
| Typ | Är det den typ jag väntar mig? En Instance och inte en tabell som byggts för att likna en? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Intervall | Är talet ändligt och inom tillåtna gränser? Har texten en rimlig längd? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Ägarskap | Äger spelaren föremålet, har den tillräckligt med pengar, har den rätt att agera på det här objektet? | Föremålet finns i spelarens inventarie; parten ligger inuti Paintable |
| Avstånd | Är spelarens karaktär tillräckligt nära i serverns kopia av världen? Lämna lite marginal för lagg. | Högst 30 studs från parten |
| Frekvens | Skickar spelaren för ofta? | En cooldown per spelare eller en gräns där anrop sparas upp |
NaN förtjänar en särskild varning. Det är ett tal, så type(x) == "number" går igenom, men varje jämförelse med det ger false, och en kontroll som x < 0 or x > 100 släpper rakt igenom det. math.isfinite(x) avvisar NaN och båda oändligheterna.
Kom ihåg gränsen för avståndskontrollen. Varje klient styr fysiken för sin egen karaktär, så en exploiter kan flytta karaktären till målet precis före anropet. Kontrollen stoppar ändå det enklaste missbruket, att påverka hela kartan från en och samma plats. Håll målparts förankrade: Roblox säkerhetsdokumentation påpekar att en exploiter kan få nätverksägarskap över oförankrade parts nära sig och dra dem närmare, och det kringgår avståndskontrollen.
Här är samma kontroller som ett ModuleScript som du kan använda i varje hanterare för remotes.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Ett riktigt tal mellan min och max. Avvisar NaN och oändlighet, som går igenom
-- den vanliga kontrollen 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
-- Ett heltal mellan min och max, för antal, index och räknare
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
-- Text med begränsad längd. utf8.len returnerar nil för ogiltig UTF-8, som
-- DataStores avvisar.
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 förväntad klass inuti en behållare som du har tillåtit.
-- En tabell som byggts för att likna en Instance klarar inte typeof-kontrollen.
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 spelarens karaktär är högst maxDistance studs från 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
-- Frekvensgräns per spelare. Varje spelare kan göra `burst` anrop på en gång och
-- får tillbaka `perSecond` anrop varje sekund. Returnerar en funktion som du anropar
-- innan arbetet: den svarar true (tillåtet) eller false (för ofta).
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
Lägg den i ServerScriptService. Kod därifrån når aldrig klienterna, så ingen kan läsa dina kontroller.
Och här är hanteraren från mönster 1, omskriven med hjälp av den. Ersätt innehållet i PaintServer:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" spelar bara roll för Luaus strikta typkontroll; under körning ändrar 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 omgång på 4, sedan 4 per sekund
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änsaren tar bort spelarens post när spelaren lämnar, så dess tabell växer inte under hela serverns livstid.
I vapen är de här kontrollerna viktigast av allt: låt aldrig klienten berätta vem som träffades. Remoten i guiden om svärd skickar inga argument alls, och servern hittar målen själv. Guiden om vapen skickar bara siktpunkten, som servern kontrollerar för typ, NaN och avstånd innan den skjuter sin egen stråle.
Menyer följer samma regel: skicka valet, inte resultatet. I guiden om NPC-dialoger skickar klienten bara numret på knappen som trycktes, och servern tittar själv på vad svaret ger. Menyn i guiden om teleporter skickar punktens namn, inte en position, och servern hittar punkten i sin egen mapp och kontrollerar hur många Wins som krävs för den.
Vad du kan och inte kan skicka
Du kan skicka tal, strängar, booleska värden, Roblox-typer som Vector3, CFrame, Color3 och Enum-element, Instances som båda sidor ser, och tabeller av allt detta. Vissa värden ändras eller försvinner på vägen:
| Du skickar | Vad som händer |
|---|---|
| En funktion | Den andra sidan får nil |
| En tabell med en metatabell | Metatabellen försvinner, tillsammans med allt som tabellen bara hade genom den |
| En tabell med både numeriska nycklar och strängnycklar | Roblox avråder från det: skicka en ren array eller en ren dictionary |
En tabell med nil-värden inuti | Undvik: Roblox avråder från nil på alla index |
| En tabell med nycklar av typen Instance, userdata eller function | Sådana nycklar blir strängar |
| En Instance som mottagaren inte ser, till exempel från ServerStorage eller skapad i ett LocalScript | Den andra sidan får nil |
| Vilken tabell som helst | Mottagaren får en kopia, inte samma tabell |
En bra vana: skicka identifierare, inte objekt eller värden. Ett föremåls namn, numret på ett alternativ, en part som servern kan hitta och kontrollera. Därifrån arbetar servern med sin egen data.
Varför RemoteFunction returnerar nil
Om InvokeServer ger dig nil, gå igenom de här punkterna i ordning:
- En väg utan returvärde. Varje utgång ur
OnServerInvokemåste returnera något. Ett tomtreturni en tidig kontroll skickar tillbakanil. - return inuti en inre funktion. Ett
returninutipcall(function() ... end), en:Connect-hanterare ellertask.spawnlämnar bara den inre funktionen. Spara resultatet, till exempellocal ok, data = pcall(...), och returnera sedandatafrån själva callbacken. - Ett värde som inte kan korsa gränsen. En funktion eller en Instance som klienten inte ser (till exempel vad som helst i ServerStorage) kommer fram som
nil. Med instance streaming påslaget kan en part som servern nyss skapade ännu inte ha nått klienten när funktionen returnerar. - Ett annat skript satte callbacken. Bara den sista tilldelningen av
OnServerInvokegäller. Sök efter remotens namn i dina skript.
Om anropet aldrig returnerar alls har inget skript satt OnServerInvoke än (Roblox håller anropen i kö tills det sätts), eller så har callbacken hakat upp sig, till exempel på WaitForChild för något som aldrig dyker upp.
UnreliableRemoteEvent: för ständiga engångsuppdateringar
UnreliableRemoteEvent har samma metoder och event som RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent och OnClientEvent. Skillnaden är att Roblox varken garanterar leverans eller ordning. Ett meddelande kan kastas utan att skickas igen när:
- det går förlorat på vägen eller väntar för länge i ett överbelastat nätverk
- dess data är större än 1000 byte
- klienten skickar oftare än gränsen (överskottet kastas, det skjuts inte upp)
- ingen hanterare är ansluten när det kommer fram (det kastas, det köas inte)
Meddelanden kan också komma i fel ordning, och deras ordning har ingen koppling till dina RemoteEvent eller RemoteFunction. Använd det när bara det senaste värdet spelar roll och nästa uppdatering kommer inom en bråkdel av en sekund: vart spelaren siktar, positionen för en kosmetisk effekt, ett värde som ändras varje bildruta. Om ordningen spelar roll, lägg ett löpnummer eller en tidsstämpel i varje meddelande och ignorera allt som är äldre än det senast hanterade.
Använd det aldrig för något som ska hända exakt en gång, till exempel ett köp, skada, en belöning eller starten på en runda. Och kontrollera dess argument på servern precis som för RemoteEvent.
Leveransordning och frekvensgränser
Roblox leveransgarantier gäller en anslutning i en riktning: från servern till en klient eller från en klient till servern.
- RemoteEvent är tillförlitliga och ordnade. Förlorade meddelanden skickas igen så länge mottagaren är ansluten, och meddelandena kommer fram i den ordning du skickade dem, även över olika RemoteEvent. Om servern skickar A, sedan B, sedan A till en spelare får den spelaren A, B, A.
- Ordningen gäller när hanterarna startar. Om en hanterare lämnar ifrån sig kontrollen, till exempel med
task.waitellerWaitForChild, kan nästa meddelande börja hanteras innan det första är klart. - RemoteFunction och RemoteEvent är inte ordnade i förhållande till varandra. Om din kod är beroende av strikt ordning, skicka relaterade meddelanden via samma typ av remote eller lägg till ditt eget löpnummer.
- Ändringar av egenskaper och attribut är inte ordnade i förhållande till remotes. Om servern ändrar en egenskap och sedan anropar en remote kan klienten se vilken som helst av de två först. Lyssna på själva ändringen, till exempel med
GetPropertyChangedSignal, i stället för att räkna med att den redan har kommit fram. - Det finns ingen hanterare än. RemoteEvent-meddelanden står i kö tills en hanterare ansluts. Kön har gränser: när den är full kastas följande meddelanden, och felet
Remote event invocation discardedvisas i Output. - En spelare som lämnar förlorar alla meddelanden som ännu inte har hunnit fram.
Frekvensgräns. RemoteEvent- och UnreliableRemoteEvent-meddelanden från klienten till servern är begränsade till ungefär 500 förfrågningar per sekund per klient, enligt dokumentationen den 30 september 2026. Gränsen delas av alla remotes av samma typ, så att dela upp en belastad remote i tio höjer den inte. Över gränsen hanteras RemoteEvent-meddelanden senare och behåller sin ordning, medan UnreliableRemoteEvent-meddelanden kastas. Motorns gräns hindrar inte på något sätt en enskild spelare från att anropa din remote 50 gånger i sekunden, så varje hanterare som ändrar något behöver ändå sin egen gräns per spelare.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent eller ett attribut?
| Använd | Till vad | Exempel | Tänk på |
|---|---|---|---|
| RemoteEvent | Meddelanden åt ett håll som måste komma fram, och i ordning | Klienten: "måla den här parten". Servern: "visa den här aviseringen" | Kontrollera varje argument på servern |
RemoteFunction med InvokeServer | Klienten behöver ett svar innan den kan fortsätta | Skriva in en kampanjkod, bekräfta ett köp | Den som anropar väntar; varje väg måste returnera ett värde |
RemoteFunction med InvokeClient | Nästan aldrig | Använd FireClient i stället | En klient som får ett fel, lämnar eller inte svarar får anropet på servern att krascha eller hänga sig |
| UnreliableRemoteEvent | Täta uppdateringar där bara den senaste spelar roll | Siktriktning, kosmetiska effekter | Meddelanden går förlorade eller byter ordning; datagräns på 1000 byte |
| Ett attribut eller value-objekt som servern sätter | Gemensamt tillstånd som alltid ska synas, även för spelare som går med senare | Rundtimer, spelfas, om en dörr är öppen | Bara serverns ändringar når alla; klienter lyssnar med GetAttributeChangedSignal eller Changed |
| BindableEvent | Kommunikation mellan skript på samma sida | Ett serverskript meddelar ett annat att rundan är slut | Korsar inte gränsen mellan servern och klienten |
Ett komplett exempel på hur RemoteFunction och kontroller fungerar tillsammans där spelare betalar finns i guiden så gör du ett butiks-GUI. När det gäller raden om attribut sätter serverskriptet i guiden om dörrar attributet Open på varje dörr varje gång den rör sig, så att vilket LocalScript som helst kan reagera på det.
Vanliga fel och lösningar
De flesta problem med remotes syns i fönstret Output (öppna det från menyn Window eller fliken Script). Titta där först och leta sedan upp ditt symptom nedan. Guiden om skriptfel går igenom vanliga felmeddelanden mer i detalj.
Infinite yield possible på WaitForChild för en remote
Skriptet väntar på en remote som aldrig dyker upp. Kontrollera att namnet och stora och små bokstäver stämmer exakt och att remoten ligger i ReplicatedStorage, inte i ServerStorage eller ServerScriptService, som klienterna inte ser.
Servern får fel värden, förskjutna med ett steg
LocalScript skickade med själva spelaren, som i remote:FireServer(player, 5). Roblox lägger redan till avsändaren som första parameter, så servern ser (player, player, 5). Anropa remote:FireServer(5).
Ingenting händer när jag anropar remoten
Kontrollera att varje anrop görs från rätt sida: FireServer och InvokeServer fungerar bara från klientkod, och FireClient, FireAllClients och InvokeClient bara från ett Script på servern. Ett LocalScript körs aldrig i ServerScriptService, ServerStorage eller direkt i Workspace; lägg det i StarterPlayerScripts, StarterGui, StarterCharacterScripts eller StarterPack. Leta sedan i Output efter ett fel inuti hanteraren.
Remote event invocation discarded
Meddelanden kom fram till ett RemoteEvent som inte hade någon ansluten hanterare, och kön blev full. Oftast kraschar skriptet med hanteraren med ett fel före raden med :Connect, är inaktiverat eller har hakat upp sig i väntan på något som aldrig laddas. Anslut hanterarna nära början av skriptet.
Det fungerar för mig, men andra spelare ser inte ändringen
Ändringen görs på klienten, i ett LocalScript eller i en OnClientEvent-hanterare. Gör den i serverhanteraren OnServerEvent.
InvokeServer returnerar aldrig
Antingen har inget skript satt OnServerInvoke (Roblox håller anropen i kö tills det sätts), eller så har callbacken hakat upp sig på något som lämnar ifrån sig kontrollen, till exempel WaitForChild eller en förfrågan till en DataStore. Lägg till print i början och slutet av callbacken för att se var den stannar.
Gör det med RoCode
RoCode kan också ställa in det här, direkt i den place du har öppen. RoCode är en AI-agent som arbetar via ett plugin för Roblox Studio, så den skapar remotes och skript i din Explorer i stället för att ge dig kod att klistra in.
Låt spelarna måla parts i mappen Paintable genom att klicka. Använd ett RemoteEvent och behåll kontrollerna på servern: bara parts från den mappen, högst 30 studs bort och högst några målningar per sekund.
- Tittar oftast först igenom din place med Search Game och Search Scripts efter en befintlig Remotes-mapp eller hanterare och använder dina mappar om de finns
- Skapar RemoteEvent i ReplicatedStorage med Create Instance och skriver ett Script på servern och ett LocalScript med Create Script
- Innan den avslutar kontrollerar den att varje skript kompilerar med Check Script inuti Studio. Det fångar kompileringsfel, inte logikfel: den kontrollerar inte typer, kör ingen linter och kör inte din kod
- Skickar ändringarna i omgångar, och varje omgång är en ångrapunkt i Studios historik
Med plugin 3.9 eller nyare kan RoCode köra ett kort speltest och läsa felen, och med plugin 3.9.11 eller nyare kan den styra en testkaraktär, men den klickar inte på parts i 3D-fönstret. Klicka på Play själv och försök knäcka kontrollerna, till exempel genom att måla en part från andra änden av kartan. Om ett fel uppstår kan Check Output läsa raderna Server och Client från ditt senaste speltest. De flesta spelsystem kommunicerar via sådana remotes, så du kommer att stöta på dem igen när du bygger ett spel system för system med RoCode. Så ansluter RoCode till Studio.
Vanliga frågor
Vad betyder securing the client-server boundary i Roblox?
Det är namnet på sidan i Roblox dokumentation om säkerhet för remotes, och idén är enkel: allt som klienten skickar via RemoteEvent eller RemoteFunction kan komma från en exploiter, så servern kontrollerar det innan den agerar. Kontrollera typen för varje argument, håll talen inom rimliga gränser, kontrollera att spelaren får göra det just nu, och begränsa hur ofta varje spelare kan anropa remoten. Checklistan för kontroller ovan visar var och en av dem i kod.
Är det säkert att använda RemoteFunction?
InvokeServer är lika säker som din callback på servern: kontrollera dess argument och begränsa frekvensen, som för vilket RemoteEvent som helst. Den riskabla riktningen är InvokeClient, eftersom en klient som får ett fel, lämnar eller aldrig returnerar ett värde får anropet på servern att krascha eller hänga sig.
Kan exploiters se och anropa mina remotes?
Ja. Allt som ligger i ReplicatedStorage når varje klient, och en modifierad klient kan anropa vilken remote som helst med vilka argument som helst. Att byta namn på eller gömma remotes gör dem inte säkra; det som gör dem säkra är att kontrollera varje argument på servern.
Kan en klient skicka ett RemoteEvent till en annan klient?
Inte direkt. Skicka det till servern, kontrollera det där och använd sedan FireClient eller FireAllClients.
Hur ofta kan jag anropa ett RemoteEvent?
Roblox dokumentation anger en gräns på ungefär 500 förfrågningar per sekund per klient för RemoteEvent- och UnreliableRemoteEvent-meddelanden som skickas till servern, gemensam för alla remotes av samma typ. Håll dig långt under den och ge varje hanterare sin egen gräns per spelare.
Når FireAllClients spelare som går med senare?
Nej. Det når spelarna som är anslutna i just det ögonblicket. För tillstånd som de som kommer sent behöver, sätt ett attribut eller ett value-objekt på servern.
Vad är skillnaden mellan RemoteEvent och BindableEvent?
RemoteEvent korsar gränsen mellan servern och klienten. BindableEvent kopplar ihop skript på samma sida, till exempel två serverskript.
Källor och vidare läsning
- Roblox Creator Docs: Remote events and callbacks (på engelska). FireServer, FireClient, InvokeServer, riskerna med InvokeClient, begränsningar för argument och leveransgarantier
- Roblox Creator Docs: Securing the client-server boundary (på engelska). Kontrollnivåer, NaN, frekvensgränser, vidarebefordran från klient till klient
- Roblox Creator Docs: Security and cheat mitigation tactics (på engelska). Vad en modifierad klient kan göra och serverns auktoritet
- Roblox Creator Docs: Network ownership, movement validation, and physics (på engelska). Varför klienten styr sin egen karaktär och gränserna för avståndskontroller
- Roblox Engine API: RemoteEvent (på engelska). Frekvensgränsen och felet invocation discarded
- Roblox Engine API: RemoteFunction (på engelska). OnServerInvoke, varningar om InvokeClient och försiktighetsåtgärder med streaming
- Roblox Engine API: UnreliableRemoteEvent (på engelska). Datagränsen på 1000 byte
- Roblox Creator Docs: Properties and attributes (på engelska). Replikeringsordning mellan ändringar av egenskaper och remote events
Så kontrollerades koden: varje skript på den här sidan klarar strikt Luau-typkontroll mot Roblox API-definitionerna (luau-lsp, 20 november 2026). Typkontrollen fångar felstavade API-namn och fel typer, men inte fel i spellogiken, så testa allt i Studio innan du publicerar.