Guide · Grunder i skriptning

RemoteEvent i Roblox: från klienten till servern och tillbaka

Ett LocalScript kan inte ändra det som andra spelare ser, och ett Script på servern kan inte nå en enskild spelares skärm. Meddelandena mellan dem skickas med RemoteEvent. I den här guiden bygger vi de tre mönster du kommer att behöva oftast, en RemoteFunction som returnerar ett svar, och kontrollerna på servern som hindrar en modifierad klient från att missbruka dem.

Uppdaterad 20 november 202618 min läsningSkriven av

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 (InvokeServer och OnServerInvoke) bara när klienten behöver ett svar. Undvik InvokeClient: 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
  1. Varför remotes behövs
  2. Konfigurera remotes
  3. 1. Från klienten till servern
  4. 2. Från servern till klienten
  5. 3. Från servern till alla
  6. RemoteFunction
  7. Checklista för kontroller
  8. Vad som inte går att skicka
  9. Returnerar nil?
  10. UnreliableRemoteEvent
  11. Ordning och gränser
  12. Vad du ska välja
  13. Common errors
  14. Med RoCode
  15. Vanliga frågor
  16. Källor och vidare läsning

Varför RemoteEvent behövs

IllustrationVarje klick ber servern att måla en part, så den nya färgen syns på båda spelarnas skärmar.

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.
Vilket anrop som utlöser vilket event
RiktningAvsändaren anroparMottagaren ansluter tillMottagaren får
Från klienten till servernremote:FireServer(...) i ett LocalScriptremote.OnServerEvent i ett ScriptDen Player som skickade meddelandet, sedan dina argument
Från servern till en klientremote:FireClient(player, ...) i ett Scriptremote.OnClientEvent i ett LocalScriptBara dina argument
Från servern till alla klienterremote:FireAllClients(...) i ett Scriptremote.OnClientEvent i ett LocalScriptBara dina argument
Klienten frågar, servern svararremoteFunction: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.

  1. I Explorer, håll muspekaren över ReplicatedStorage, klicka på knappen + och infoga en Folder. Döp mappen till Remotes.
  2. Håll muspekaren över Remotes, klicka på + och infoga ett RemoteEvent. Byt namn på det så att namnet beskriver syftet, till exempel PaintRequest.
  3. Upprepa för varje remote. Den här guiden använder två RemoteEvent (PaintRequest och Notify) och en RemoteFunction (RedeemCode).
Explorer: allt som den här guiden lägger till, avsnitt för avsnitt
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.

  1. I Workspace, infoga en Folder som heter Paintable och lägg några förankrade (anchored) Part i den.
  2. Kontrollera att ReplicatedStorage.Remotes innehåller ett RemoteEvent som heter PaintRequest.
  3. Infoga ett Script som heter PaintServer i ServerScriptService och ett LocalScript som heter PaintClient i StarterPlayer, StarterPlayerScripts, med koden nedan.
Script i ServerScriptService med namnet PaintServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- 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.

LocalScript i StarterPlayerScripts med namnet PaintClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")

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

local COLOUR_COUNT = 4 -- de 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.

Script i ServerScriptService med namnet WelcomeServer
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
LocalScript i StarterPlayerScripts med namnet NotifyClient
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.

Script i ServerScriptService med namnet FinishAnnouncer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

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

finishLine.Touched:Connect(function(hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player or finished[player] then
		return -- 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.

  1. I ReplicatedStorage.Remotes, infoga en RemoteFunction som heter RedeemCode.
  2. I StarterGui, infoga en ScreenGui som heter CodeGui och inuti den en TextBox som heter CodeBox. Storlek och placering väljer du själv.
  3. Lägg till Script nedan i ServerScriptService och LocalScript inuti CodeBox.
Script i ServerScriptService med namnet RedeemServer
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.

LocalScript i TextBox CodeBox med namnet RedeemClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

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

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

	-- InvokeServer 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 InvokeClient ett 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.

Checklista för servern
KontrollFrågan servern ställerExempel
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
FrekvensSkickar 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.

ModuleScript i ServerScriptService med namnet RemoteGuard
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:

Script i ServerScriptService med namnet 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:

Argument som inte kommer fram som de skickades
Du skickarVad som händer
En funktionDen andra sidan får nil
En tabell med en metatabellMetatabellen försvinner, tillsammans med allt som tabellen bara hade genom den
En tabell med både numeriska nycklar och strängnycklarRoblox avråder från det: skicka en ren array eller en ren dictionary
En tabell med nil-värden inutiUndvik: Roblox avråder från nil på alla index
En tabell med nycklar av typen Instance, userdata eller functionSådana nycklar blir strängar
En Instance som mottagaren inte ser, till exempel från ServerStorage eller skapad i ett LocalScriptDen andra sidan får nil
Vilken tabell som helstMottagaren 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:

  1. En väg utan returvärde. Varje utgång ur OnServerInvoke måste returnera något. Ett tomt return i en tidig kontroll skickar tillbaka nil.
  2. return inuti en inre funktion. Ett return inuti pcall(function() ... end), en :Connect-hanterare eller task.spawn lämnar bara den inre funktionen. Spara resultatet, till exempel local ok, data = pcall(...), och returnera sedan data från själva callbacken.
  3. 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.
  4. Ett annat skript satte callbacken. Bara den sista tilldelningen av OnServerInvoke gä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.wait eller WaitForChild, 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 discarded visas 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?

Så väljer du hur klienten och servern ska kommunicera
AnvändTill vadExempelTänk på
RemoteEventMeddelanden åt ett håll som måste komma fram, och i ordningKlienten: "måla den här parten". Servern: "visa den här aviseringen"Kontrollera varje argument på servern
RemoteFunction med InvokeServerKlienten behöver ett svar innan den kan fortsättaSkriva in en kampanjkod, bekräfta ett köpDen som anropar väntar; varje väg måste returnera ett värde
RemoteFunction med InvokeClientNästan aldrigAnvänd FireClient i ställetEn klient som får ett fel, lämnar eller inte svarar får anropet på servern att krascha eller hänga sig
UnreliableRemoteEventTäta uppdateringar där bara den senaste spelar rollSiktriktning, kosmetiska effekterMeddelanden går förlorade eller byter ordning; datagräns på 1000 byte
Ett attribut eller value-objekt som servern sätterGemensamt tillstånd som alltid ska synas, även för spelare som går med senareRundtimer, spelfas, om en dörr är öppenBara serverns ändringar når alla; klienter lyssnar med GetAttributeChangedSignal eller Changed
BindableEventKommunikation mellan skript på samma sidaEtt serverskript meddelar ett annat att rundan är slutKorsar 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.

Du skriver

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.

RoCode gör
  • 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

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.

Testa RoCode i ditt eget spel.

Gratis krediter varje dag, inget kort krävs. Installera pluginet, beskriv en funktion och kontrollera vad som dök upp i Studio.