Tutorial · Grundlæggende scripting

RemoteEvent i Roblox: fra klient til server og tilbage

Et LocalScript kan ikke ændre det, andre spillere ser, og et server-Script kan ikke nå ind på én spillers skærm. Beskeder mellem dem sendes med RemoteEvents. I denne guide bygger vi de tre mønstre, du oftest får brug for, en RemoteFunction, der returnerer et svar, og de tjek på serveren, der forhindrer en modificeret klient i at misbruge dem.

Opdateret 20. november 202618 min. læsningSkrevet af

Kort fortalt

En RemoteEvent er et objekt, der som regel ligger i ReplicatedStorage og sender beskeder over grænsen mellem klient og server. Et LocalScript kalder FireServer, og serveren modtager beskeden i OnServerEvent, hvor den Player, der sendte den, er tilføjet som første argument. Serveren kalder FireClient(player, ...) eller FireAllClients(...), og LocalScripts modtager beskeden i OnClientEvent.

  • Brug kun RemoteFunction (InvokeServer og OnServerInvoke), når klienten har brug for et svar. Undgå InvokeClient: en klient, der fik en fejl, gik ud eller aldrig returnerede en værdi, ødelægger kaldet på serveren.
  • Stol aldrig på det, klienten sender. Tjek på serveren type, interval og ejerskab for hvert argument, afstanden til spilleren og hvor ofte den kalder remoten.
  • Funktioner, metatabeller og objekter, som den anden side ikke kan se, overlever ikke overførslen. UnreliableRemoteEvent kan miste beskeder eller ændre deres rækkefølge og kasserer alle data over 1000 bytes.
På denne side
  1. Hvorfor remotes
  2. Opsætning af remotes
  3. 1. Fra klient til server
  4. 2. Fra server til klient
  5. 3. Fra server til alle
  6. RemoteFunction
  7. Tjekliste
  8. Hvad du ikke kan sende
  9. Returnerer nil?
  10. UnreliableRemoteEvent
  11. Rækkefølge og grænser
  12. Hvad du skal vælge
  13. Common errors
  14. Med RoCode
  15. Ofte stillede spørgsmål
  16. Kilder og videre læsning

Hvorfor RemoteEvents er nødvendige

IllustrationHvert klik beder serveren male en part, så den nye farve kan ses på begge spilleres skærme.

Ethvert Roblox-spil kører som én server plus én klient for hver spiller. Serveren bestemmer: et nyt objekt eller en ændret egenskab når kun ud til alle spillere, når serveren laver det. En ændring lavet i et LocalScript bliver på den ene enhed, med få undtagelser som spillerens egen karakter, hvis bevægelse styres af klienten. Derfor skal klienten, når et klik eller et tastetryk skal ændre den fælles verden, bede serveren om det, og når serveren vil have én spillers skærm til at reagere, skal den fortælle klienten det. Hvis opdelingen i Script og LocalScript er ny for dig, så læs først Script vs LocalScript vs ModuleScript (på engelsk). Hvis selve scripting er nyt, så start med, hvordan man skriver scripts i Roblox Studio.

Til at krydse den grænse giver Roblox tre objekter:

  • RemoteEvent: en besked én vej. Afsenderen fortsætter straks.
  • RemoteFunction: en forespørgsel, der venter på svar. Den kaldende kode holder pause, indtil den anden side returnerer en værdi.
  • UnreliableRemoteEvent: en besked én vej, der kan gå tabt eller komme i forkert rækkefølge, men belaster netværket mindre. Passer til data, der ændrer sig hele tiden.
Hvilket kald udløser hvilket event
RetningAfsenderen kalderModtageren forbinder tilModtageren får
Fra klient til serverremote:FireServer(...) i et LocalScriptremote.OnServerEvent i et ScriptDen Player, der sendte beskeden, og derefter dine argumenter
Fra server til én klientremote:FireClient(player, ...) i et Scriptremote.OnClientEvent i et LocalScriptKun dine argumenter
Fra server til alle klienterremote:FireAllClients(...) i et Scriptremote.OnClientEvent i et LocalScriptKun dine argumenter
Klienten spørger, serveren svarerremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player og derefter dine argumenter. Den, der kaldte, får det, funktionen returnerede

Klienter kan ikke sende beskeder direkte til hinanden. For at sende noget fra én spiller til de andre sender du det til serveren, tjekker det der og lader serveren sende det videre med FireClient eller FireAllClients. Ifølge Robloxs sikkerhedsanbefalinger fungerer serveren her som dørvogter, ikke som en simpel videresender.

Hvor remotes skal ligge

En remote skal ligge et sted, hvor både serveren og klienterne kan se den. Det almindelige sted er ReplicatedStorage; Robloxs dokumentation nævner, at Workspace eller et Tool også kan bruges i nogle tilfælde. ServerStorage og ServerScriptService er kun tilgængelige for serveren, så et LocalScript, der venter på en remote derfra, venter for evigt.

  1. I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og indsætter en Folder. Kald mappen Remotes.
  2. Hold musen over Remotes, klik på +, og indsæt en RemoteEvent. Omdøb den, så navnet beskriver formålet, for eksempel PaintRequest.
  3. Gentag for hver remote. Denne guide bruger to RemoteEvents (PaintRequest og Notify) og én RemoteFunction (RedeemCode).
Explorer: alt, hvad denne guide tilføjer, afsnit for afsnit
ReplicatedStorage
  Remotes  Folder  new
    PaintRequest  RemoteEvent  new
    Notify  RemoteEvent  new
    RedeemCode  RemoteFunction  new
ServerScriptService
  PaintServer  Script  new
  WelcomeServer  Script  new
  FinishAnnouncer  Script  new
  RedeemServer  Script  new
  RemoteGuard  ModuleScript  new
StarterPlayer
  StarterPlayerScripts
    PaintClient  LocalScript  new
    NotifyClient  LocalScript  new
StarterGui
  CodeGui  ScreenGui  new
    CodeBox  TextBox  new
      RedeemClient  LocalScript  new
Workspace
  Paintable  Folder  new
  FinishLine  Part  new

Scripts i denne guide finder remotes med WaitForChild. Den returnerer straks, hvis remoten allerede er der, og venter, hvis den ikke er der endnu, for eksempel når et server-script opretter remotes under spillet. Lav en separat remote for hver slags forespørgsel: så tjekker hver handler på serveren én form for argumenter, og det er meget nemmere at gøre rigtigt end med én remote til alt.

Mønster 1: fra klient til server, med tjek på serveren

Den mest almindelige opgave: spilleren gør noget på sin skærm, og serveren afgør, hvad der sker. Her trykker spilleren på Q for at vælge en af fire farver og klikker eller trykker på en part for at male den. Alle ser den nye farve, fordi serveren maler.

Klienten sender to ting: hvilken part og farvens nummer. Selve farven sender den aldrig, og i andre spil skal den på samme måde aldrig sende en pris, en belønning eller en skadesværdi. En modificeret klient kan sende hvad som helst, så de rigtige data (her paletten) holder serveren, og argumenterne behandler den som en forespørgsel, der skal tjekkes.

  1. Indsæt en Folder med navnet Paintable i Workspace, og læg nogle ankrede Parts i den.
  2. Tjek, at der er en RemoteEvent med navnet PaintRequest i ReplicatedStorage.Remotes.
  3. Indsæt et Script med navnet PaintServer i ServerScriptService og et LocalScript med navnet PaintClient i StarterPlayer, StarterPlayerScripts, med koden nedenfor.
Script i ServerScriptService med navnet 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")

-- Farverne tilhører serveren. Klienten sender kun et nummer, der vælger en af dem.
local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local MAX_DISTANCE = 30 -- studs mellem karakteren og parten
local COOLDOWN_SECONDS = 0.25

local lastPaint: { [Player]: number } = {}

-- Den første parameter er altid den spiller, der kaldte remoten. Den indsættes af Roblox,
-- så den kan man stole på. Alt efter den kom fra klienten, og det kan man ikke stole på.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Type: en rigtig part, ikke en tabel, der foregiver at være en
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Interval: et heltal fra 1 til 4. NaN og uendelig sorteres også fra her.
	if type(colourIndex) ~= "number" or not math.isfinite(colourIndex) then
		return
	end
	if colourIndex % 1 ~= 0 or colourIndex < 1 or colourIndex > #PALETTE then
		return
	end

	-- 3. Tilladt mål: kun parts i mappen Paintable, intet andet i spillet
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Afstand: spillerens karakter skal være tæt på parten
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if not (root and root:IsA("BasePart")) then
		return
	end
	if (root.Position - part.Position).Magnitude > MAX_DISTANCE then
		return
	end

	-- 5. Hyppighedsgrænse: én maling pr. spiller hvert kvarte sekund
	local now = os.clock()
	local last = lastPaint[player]
	if last and now - last < COOLDOWN_SECONDS then
		return
	end
	lastPaint[player] = now

	part.Color = PALETTE[colourIndex]
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastPaint[player] = nil
end)

Hvert tjek, der ikke bestås, laver bare return. Der er ingen grund til at forklare en snyderklient, hvorfor den blev afvist.

LocalScript i StarterPlayerScripts med navnet 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 rigtige farver holder serveren
local selectedColour = 1

-- Strålen kan kun ramme parts inde i mappen Paintable
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }

UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
	if gameProcessed then
		return -- tasten eller klikket gik til chatten eller en knap
	end

	if input.KeyCode == Enum.KeyCode.Q then
		selectedColour = selectedColour % COLOUR_COUNT + 1
		return
	end

	local isClick = input.UserInputType == Enum.UserInputType.MouseButton1
	local isTap = input.UserInputType == Enum.UserInputType.Touch
	if isClick or isTap then
		local camera = workspace.CurrentCamera
		local ray = camera:ScreenPointToRay(input.Position.X, input.Position.Y)
		local result = workspace:Raycast(ray.Origin, ray.Direction * 500, rayParams)
		if result then
			-- Vi beder, vi beordrer ikke: serveren afgør, om der skal males
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed er true, når motoren allerede har håndteret dette input, som regel i brugerfladen: et klik på en knap eller taster skrevet i et tekstfelt som chatlinjen. Takket være dette tjek ændrer bogstavet Q, skrevet i en besked, ikke farven.

Mønster 2: fra server til én klient

Serveren sender en besked til én spiller med FireClient. Det første argument er den Player, den er adresseret til, og handleren på klienten får kun argumenterne efter den. Brug det til alt personligt: en notifikation, et belønningsvindue, en lyd, som kun den spiller skal høre. Cutscene-guiden er et større gennemgået eksempel: serveren afgør, hvornår spilleren ser en cutscene, og sender dens frames til den ene spiller med FireClient, mens spillerens enhed flytter kameraet.

Dette par scripts viser en velkomst, når en spiller kommer ind. LocalScriptet bygger selv et lille banner, så du behøver ikke at sætte en GUI op.

Script i ServerScriptService med navnet 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ørste argument vælger, hvilken klient der får beskeden. Ingen andre ser den.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- I Studio kan du komme ind, før dette script forbinder, så vi byder alle velkommen, der allerede er her
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript i StarterPlayerScripts med navnet NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local player = Players.LocalPlayer

-- Et lille banner øverst på skærmen, bygget i koden
local gui = Instance.new("ScreenGui")
gui.Name = "Notifications"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local label = Instance.new("TextLabel")
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 16)
label.Size = UDim2.fromOffset(420, 44)
label.BackgroundColor3 = Color3.fromRGB(18, 11, 31)
label.TextColor3 = Color3.new(1, 1, 1)
label.TextScaled = true
label.Visible = false
label.Parent = gui

local messageCount = 0

-- Her er der ingen player-parameter: serveren har allerede valgt, hvem der får beskeden
notify.OnClientEvent:Connect(function(message: string)
	messageCount += 1
	local thisMessage = messageCount
	label.Text = message
	label.Visible = true
	task.delay(4, function()
		if messageCount == thisMessage then -- skjul, hvis den ikke er erstattet af en nyere besked
			label.Visible = false
		end
	end)
end)

Serveren sender beskeden ved PlayerAdded, og det kan ske, før dette LocalScript forbinder sin handler. Det er i orden: Roblox sætter RemoteEvent-beskeder, der kom, før handleren fandtes, i kø og leverer dem i rækkefølge, så snart handleren forbinder.

Klienten behøver ikke at beskytte sig mod serveren: kun serverkode kan udløse OnClientEvent. Annotationen message: string er til typekontrol; det er ikke et tjek under kørsel.

Mønster 3: fra server til alle klienter

FireAllClients sender den samme besked til hver forbundet spiller. Den har intet Player-argument, og hver klient modtager beskeden i den samme OnClientEvent som før, så scriptet NotifyClient fra mønster 2 viser den allerede.

Dette Script meddeler alle, når en spiller første gang rører målstregen. Tilføj en ankret Part med navnet FinishLine i Workspace, og tilføj derefter Scriptet i ServerScriptService.

Script i ServerScriptService med navnet 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 -- ikke en spiller eller allerede meddelt
	end
	finished[player] = true

	-- Hver forbundet klient kører sin OnClientEvent-handler med denne tekst
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

Players.PlayerRemoving:Connect(function(player: Player)
	finished[player] = nil
end)

En exploiter kan udløse Touched for sin karakter fra en hvilken som helst afstand, men for en meddelelse, der vises én gang pr. spiller, er det harmløst. Hvis du senere giver en belønning for at nå målet, så tilføj tjek på serveren før udbetalingen, for eksempel en minimumstid fra rundens start.

FireAllClients når kun de spillere, der er forbundet i det øjeblik. Den, der kommer ind et sekund senere, ser ikke beskeden. Det passer til enkeltstående øjeblikke som en meddelelse, en eksplosionseffekt eller en lyd, men ikke til tilstand som en rundetimer eller spillets nuværende fase. Til tilstand sætter du en attribut på serveren, for eksempel ReplicatedStorage:SetAttribute("TimeLeft", 30), og læser den på klienten med GetAttribute og GetAttributeChangedSignal("TimeLeft"). Attributter replikeres til hver klient, også til spillere, der kommer senere.

RemoteFunction: når klienten har brug for et svar

En RemoteEvent virker efter princippet "send og glem". En RemoteFunction får den, der kalder, til at vente: InvokeServer sætter den kode, der kaldte den, på pause, indtil serverens funktion OnServerInvoke returnerer en værdi, og giver derefter det, den returnerede. Brug den, når klienten ikke kan fortsætte uden et svar, for eksempel "var denne kode rigtig?". Når der ikke skal bruges et svar, anbefaler Roblox en RemoteEvent, fordi den ikke venter.

Eksempel: et felt, hvor spillerne skriver en kampagnekode. Serveren holder koderne, tjekker teksten og returnerer to værdier: om det virkede, og den besked, der skal vises.

  1. Indsæt en RemoteFunction med navnet RedeemCode i ReplicatedStorage.Remotes.
  2. Indsæt en ScreenGui med navnet CodeGui i StarterGui og indeni en TextBox med navnet CodeBox. Vælg størrelse og placering efter smag.
  3. Tilføj Scriptet nedenfor i ServerScriptService og LocalScriptet inde i CodeBox.
Script i ServerScriptService med navnet RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction

-- Koderne bor på serveren, hvor ingen spiller kan læse dem
local CODES: { [string]: number } = {
	LAUNCH = 100,
	THANKYOU = 50,
}
local MAX_LENGTH = 20
local COOLDOWN_SECONDS = 2

local usedCodes: { [Player]: { [string]: boolean } } = {}
local lastTry: { [Player]: number } = {}

-- Tildel med =. OnServerInvoke er et callback, ikke et event, man forbinder til med Connect.
redeemCode.OnServerInvoke = function(player: Player, code: unknown): (boolean, string)
	local now = os.clock()
	local last = lastTry[player]
	if last and now - last < COOLDOWN_SECONDS then
		return false, "Wait a moment before trying again"
	end
	lastTry[player] = now

	if type(code) ~= "string" or #code == 0 or #code > MAX_LENGTH then
		return false, "Type a code first"
	end

	local key = string.upper(code)
	local reward = CODES[key]
	if not reward then
		return false, "That code doesn't exist"
	end

	local used = usedCodes[player]
	if not used then
		used = {}
		usedCodes[player] = used
	end
	if used[key] then
		return false, "You already used that code"
	end

	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if not (coins and coins:IsA("IntValue")) then
		return false, "Coins aren't set up in this game yet"
	end

	used[key] = true
	coins.Value += reward
	return true, `Code accepted: +{reward} coins`
end

Players.PlayerRemoving:Connect(function(player: Player)
	usedCodes[player] = nil
	lastTry[player] = nil
end)

Det lægger til statistikken Coins fra guiden til leaderboards. Brugte koder huskes kun, indtil spilleren går, så i denne form kan en spiller komme ind igen og indtaste den samme kode igen. Hvis mønterne gemmes, er det gratis mønter ved hvert genbesøg: før du bruger det i et live spil, så gem hver spillers brugte koder sammen med spillerens gemte data i et datalager.

LocalScript i TextBox CodeBox med navnet 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 sætter denne funktion på pause, indtil serverens callback returnerer en værdi.
	-- pcall forhindrer LocalScriptet i at stoppe, hvis kaldet fejlede.
	local ok, accepted, message = pcall(function()
		return redeemCode:InvokeServer(code)
	end)

	if ok and type(message) == "string" then
		box.PlaceholderText = message
		box.PlaceholderColor3 = if accepted == true then GREEN else RED
	else
		box.PlaceholderText = "Something went wrong, try again"
		box.PlaceholderColor3 = RED
	end
end)

En RemoteFunction har præcis ét callback på serveren. Hvis to scripts sætter OnServerInvoke på den samme RemoteFunction, virker kun det sidste.

Hvorfor InvokeClient er farlig

En RemoteFunction virker også den anden vej, med InvokeClient på serveren og OnClientInvoke på klienten. Robloxs dokumentation nævner tre alvorlige risici:

  • Hvis klientens callback giver en fejl, giver serveren også en fejl.
  • Hvis spilleren går under kaldet, giver InvokeClient en fejl.
  • Hvis klienten aldrig returnerer en værdi, venter server-scriptet for evigt.

En modificeret klient styrer sit eget callback, så en snyder kan bevidst fremkalde det tredje tilfælde og holde den servertråd så længe, den vil. For at opdatere en spillers skærm bruger du FireClient. Hvis serveren virkelig har brug for information fra klienten, så send en RemoteEvent, lad klienten svare via en anden RemoteEvent, og betragt et manglende svar som et normalt tilfælde på serveren.

Tjek hvert argument på serveren

En exploiter kan kalde enhver RemoteEvent eller RemoteFunction så mange gange, den vil, og med alle mulige argumenter. Det eneste, den ikke kan forfalske, er den første parameter: Roblox indsætter selv den Player, der sendte beskeden. Alt, der kommer efter, skal tjekkes, før serveren handler. Det nytter ikke at skjule remoten eller tjekke i et LocalScript, fordi snyderen styrer sin egen klient.

Tjekliste til serveren
TjekSpørgsmålet, serveren stillerEksempel
TypeEr det den type, jeg forventer? En Instance og ikke en tabel bygget til at ligne en?typeof(part) == "Instance" and part:IsA("BasePart")
IntervalEr tallet endeligt og inden for de tilladte grænser? Har teksten en rimelig længde?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
EjerskabEjer spilleren genstanden, har den penge nok, har den ret til at handle med dette objekt?Genstanden er i spillerens inventar; parten ligger inde i Paintable
AfstandEr spillerens karakter tæt nok på i serverens kopi af verden? Giv lidt margin til lag.Højst 30 studs fra parten
HyppighedSender denne spiller for ofte?Cooldown pr. spiller eller en grænse med opsparede kald

NaN fortjener en særlig advarsel. Det er et tal, så type(x) == "number" består, men enhver sammenligning med det giver false, og et tjek som x < 0 or x > 100 lader det slippe igennem. math.isfinite(x) afviser NaN og begge uendeligheder.

Husk grænsen for afstandstjekket. Hver klient styrer fysikken for sin karakter, så en exploiter kan flytte karakteren hen til målet før kaldet. Tjekket stopper stadig det simpleste misbrug, hvor man fra ét sted handler på hele kortet. Hold målparts ankrede: Robloxs sikkerhedsdokumentation nævner, at en exploiter kan få network ownership over ikke-ankrede parts i nærheden og trække dem tættere på, og det kommer uden om afstandstjekket.

Her er de samme tjek som et ModuleScript, du kan bruge i hver remote-handler.

ModuleScript i ServerScriptService med navnet RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Et rigtigt tal mellem min og max. Afviser NaN og uendelig, som består
-- det almindelige tjek type(x) == "number".
function RemoteGuard.number(value: unknown, min: number, max: number): number?
	if type(value) ~= "number" or not math.isfinite(value) then
		return nil
	end
	if value < min or value > max then
		return nil
	end
	return value
end

-- Et heltal mellem min og max, til antal, indekser og tællere
function RemoteGuard.integer(value: unknown, min: number, max: number): number?
	local n = RemoteGuard.number(value, min, max)
	if n and n % 1 == 0 then
		return n
	end
	return nil
end

-- Tekst med længdegrænse. utf8.len returnerer nil for ugyldig UTF-8, som
-- datalagre afviser.
function RemoteGuard.text(value: unknown, maxLength: number): string?
	if type(value) ~= "string" or #value > maxLength or utf8.len(value) == nil then
		return nil
	end
	return value
end

-- En Instance af den forventede klasse inde i en container, du har tilladt.
-- En tabel bygget til at ligne en Instance består ikke typeof-tjekket.
function RemoteGuard.instanceIn(value: unknown, className: string, container: Instance): Instance?
	if typeof(value) ~= "Instance" then
		return nil
	end
	if not value:IsA(className) or not value:IsDescendantOf(container) then
		return nil
	end
	return value
end

-- True, når spillerens karakter er højst maxDistance studs fra position
function RemoteGuard.isNear(player: Player, position: Vector3, maxDistance: number): boolean
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	if not (root and root:IsA("BasePart")) then
		return false
	end
	return (root.Position - position).Magnitude <= maxDistance
end

-- Hyppighedsgrænse pr. spiller. Hver spiller kan lave `burst` kald på én gang og
-- får `perSecond` kald tilbage hvert sekund. Returnerer en funktion, der kaldes
-- før arbejdet: den svarer true (tilladt) eller false (for ofte).
function RemoteGuard.limiter(burst: number, perSecond: number): (Player) -> boolean
	local buckets: { [Player]: { tokens: number, updated: number } } = {}

	Players.PlayerRemoving:Connect(function(player: Player)
		buckets[player] = nil
	end)

	return function(player: Player): boolean
		local now = os.clock()
		local bucket = buckets[player]
		if not bucket then
			bucket = { tokens = burst, updated = now }
			buckets[player] = bucket
		end
		bucket.tokens = math.min(burst, bucket.tokens + (now - bucket.updated) * perSecond)
		bucket.updated = now
		if bucket.tokens < 1 then
			return false
		end
		bucket.tokens -= 1
		return true
	end
end

return RemoteGuard

Hold den i ServerScriptService. Kode derfra når aldrig ud til klienterne, så ingen kan læse dine tjek.

Og her er handleren fra mønster 1, skrevet om med den. Erstat indholdet af PaintServer:

Script i ServerScriptService med navnet PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" har kun betydning for Luaus strenge typekontrol; under kørsel ændrer det ingenting
local RemoteGuard = require(ServerScriptService:WaitForChild("RemoteGuard")) :: any

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

local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local canPaint = RemoteGuard.limiter(4, 4) -- en pakke på 4, derefter 4 i sekundet

paintRequest.OnServerEvent:Connect(function(player: Player, partArg: unknown, colourArg: unknown)
	local part = RemoteGuard.instanceIn(partArg, "BasePart", paintable) :: BasePart?
	local colourIndex = RemoteGuard.integer(colourArg, 1, #PALETTE) :: number?
	if not part or not colourIndex then
		return
	end
	if not RemoteGuard.isNear(player, part.Position, 30) or not canPaint(player) then
		return
	end
	part.Color = PALETTE[colourIndex]
end)

Begrænseren sletter spillerens post, når den går, så dens tabel vokser ikke, så længe serveren kører.

I våben er disse tjek vigtigst: lad aldrig klienten melde, hvem der blev ramt. Remoten fra sværd-guiden har slet ingen argumenter, og serveren finder selv målene. Våben-guiden sender kun sigtepunktet, som serveren tjekker for type, NaN og afstand, før den sender sin egen stråle.

Menuer følger samme regel: send valget, ikke resultatet. I guiden til NPC-dialoger sender klienten kun nummeret på den knap, der blev trykket på, og serveren ser selv, hvad det svar giver. Menuen fra teleport-guiden sender stedets navn, ikke en position, og serveren finder stedet i sin mappe og tjekker, hvor mange Wins det kræver.

Hvad du kan og ikke kan sende

Du kan sende tal, strenge, booleske værdier, Roblox-typer som Vector3, CFrame, Color3 og Enum-elementer, Instances, som begge sider kan se, og tabeller af alt det. Nogle værdier ændres eller forsvinder undervejs:

Argumenter, der ikke kommer frem, som de blev sendt
Du senderHvad der sker
En funktionDen anden side får nil
En tabel med en metatabelMetatabellen går tabt sammen med alt, hvad tabellen kun havde via den
En tabel, hvor tal- og strengnøgler er blandetRoblox fraråder det: send et rent array eller en ren ordbog
En tabel med nil-værdier indeniUndgå det: Roblox fraråder nil på ethvert indeks
En tabel med nøgler af typen Instance, userdata eller functionSådanne nøgler bliver til strenge
En Instance, som modtageren ikke kan se, for eksempel fra ServerStorage eller oprettet i et LocalScriptDen anden side får nil
Enhver tabelModtageren får en kopi, ikke den samme tabel

En god vane: send identifikatorer, ikke objekter eller værdier. Et genstandsnavn, et nummer på en mulighed, en part, som serveren kan finde og tjekke. Derefter arbejder serveren med sine egne data.

Hvorfor RemoteFunction returnerer nil

Hvis InvokeServer giver dig nil, så gå disse punkter igennem i rækkefølge:

  1. En vej uden returværdi. Hver udgang fra OnServerInvoke skal returnere noget. En tom return i et tidligt tjek sender nil tilbage.
  2. return inde i en indlejret funktion. return inde i pcall(function() ... end), en :Connect-handler eller task.spawn forlader kun den indre funktion. Gem resultatet, for eksempel local ok, data = pcall(...), og returnér derefter data fra selve callbacket.
  3. En værdi, der ikke kan krydse grænsen. En funktion eller en Instance, som klienten ikke kan se (for eksempel alt i ServerStorage), kommer frem som nil. Med instance streaming slået til har en part, som serveren lige har oprettet, måske endnu ikke nået klienten, når funktionen returnerer.
  4. Et andet script satte callbacket. Kun den sidste tildeling af OnServerInvoke virker. Søg efter remotens navn i dine scripts.

Hvis kaldet slet ikke returnerer, har intet script endnu sat OnServerInvoke (Roblox holder kald i kø, indtil det sættes), eller callbacket hænger, for eksempel på WaitForChild for noget, der aldrig dukker op.

UnreliableRemoteEvent: til konstante engangsopdateringer

En UnreliableRemoteEvent har de samme metoder og events som en RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent og OnClientEvent. Forskellen er, at Roblox hverken garanterer levering eller rækkefølge. En besked kan blive kasseret uden at blive sendt igen, når:

  • den går tabt undervejs eller venter for længe i et overbelastet netværk
  • dens data er større end 1000 bytes
  • klienten sender oftere end grænsen (det overskydende kasseres i stedet for at blive udskudt)
  • der ikke er forbundet nogen handler, når den kommer (den smides væk i stedet for at blive sat i kø)

Beskeder kan også komme i forkert rækkefølge, og deres rækkefølge har intet med dine RemoteEvents eller RemoteFunctions at gøre. Brug den, når kun den nyeste værdi betyder noget, og den næste opdatering kommer om en brøkdel af et sekund: hvor spilleren sigter, positionen af en kosmetisk effekt, en værdi, der ændrer sig hvert frame. Hvis rækkefølgen betyder noget, så læg et løbenummer eller et tidsstempel i hver besked, og ignorér alt, der er ældre end den senest behandlede.

Brug den aldrig til noget, der skal ske præcis én gang, for eksempel et køb, skade, en belønning eller starten af en runde. Og tjek dens argumenter på serveren præcis som ved en RemoteEvent.

Leveringsrækkefølge og hyppighedsgrænser

Robloxs leveringsgarantier gælder én forbindelse i én retning: fra serveren til én klient eller fra én klient til serveren.

  • RemoteEvents er pålidelige og ordnede. Tabte beskeder sendes igen, så længe modtageren er forbundet, og beskeder kommer frem i den rækkefølge, du sendte dem, selv på tværs af forskellige RemoteEvents. Hvis serveren sender A, så B, så A til en spiller, får den spiller A, B, A.
  • Rækkefølgen gælder det tidspunkt, handlerne starter. Hvis en handler yielder, for eksempel med task.wait eller WaitForChild, kan den næste besked begynde at blive behandlet, før den første er færdig.
  • RemoteFunctions og RemoteEvents er ikke ordnet i forhold til hinanden. Hvis din kode afhænger af en streng rækkefølge, så send relaterede beskeder via samme type remote, eller tilføj dit eget løbenummer.
  • Ændringer af egenskaber og attributter er ikke ordnet i forhold til remotes. Hvis serveren ændrer en egenskab og derefter kalder en remote, kan klienten se en hvilken som helst af de to først. Lyt efter selve ændringen, for eksempel med GetPropertyChangedSignal, i stedet for at regne med, at den allerede er kommet.
  • Handleren findes ikke endnu. RemoteEvent-beskeder står i kø, indtil en handler forbinder. Køen har grænser: når den er fuld, kasseres de næste beskeder, og i Output vises fejlen Remote event invocation discarded.
  • En spiller, der går, mister alle beskeder, der endnu ikke er nået frem.

Hyppighedsgrænse. RemoteEvent- og UnreliableRemoteEvent-beskeder fra klient til server er begrænset til cirka 500 forespørgsler i sekundet pr. klient ifølge dokumentationen pr. 30. september 2026. Grænsen er fælles for alle remotes af samme type, så at dele én travl remote op i ti hæver den ikke. Over grænsen behandles RemoteEvent-beskeder senere og beholder rækkefølgen, mens UnreliableRemoteEvent-beskeder kasseres. Motorens grænse forhindrer ikke én spiller i at kalde din remote 50 gange i sekundet, så hver handler, der ændrer noget, har stadig brug for sin egen grænse pr. spiller.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent eller en attribut?

Sådan vælger du, hvordan klient og server kommunikerer
BrugTil hvadEksempelHvad du skal være opmærksom på
RemoteEventBeskeder én vej, der skal nå frem, og i rækkefølgeKlient: "mal denne part". Server: "vis denne notifikation"Tjek hvert argument på serveren
RemoteFunction med InvokeServerKlienten skal have et svar, før den kan fortsætteIndtast en kampagnekode, bekræft et købDen, der kalder, venter; hver vej skal returnere en værdi
RemoteFunction med InvokeClientNæsten aldrigBrug FireClient i stedetEn klient, der får en fejl, går eller ikke svarer, ødelægger eller fastlåser kaldet på serveren
UnreliableRemoteEventHyppige opdateringer, hvor kun den sidste betyder nogetSigteretning, kosmetiske effekterBeskeder går tabt eller skifter rækkefølge; datagrænse på 1000 bytes
En attribut eller et value-objekt sat af serverenFælles tilstand, der altid skal kunne ses, også af spillere, der kommer senereRundetimer, spillets fase, om en dør er åbenKun serverens ændringer når ud til alle; klienter lytter med GetAttributeChangedSignal eller Changed
BindableEventKommunikation mellem scripts på samme sideÉt server-script fortæller et andet, at runden er slutGår ikke mellem server og klient

Et fuldt eksempel på, hvordan RemoteFunction og tjek arbejder sammen der, hvor spillere betaler, finder du i guiden sådan laver du en butiks-GUI. Hvad angår rækken om attributter, sætter server-scriptet fra dør-guiden attributten Open på hver dør, hver gang den bevæger sig, så ethvert LocalScript kan reagere på den.

Almindelige fejl og løsninger

De fleste problemer med remotes kan ses i Output-vinduet (åbn det fra menuen Window eller fanen Script). Kig der først, og find derefter dit symptom nedenfor. Guiden til script-fejl gennemgår almindelige fejlbeskeder mere detaljeret.

Infinite yield possible ved WaitForChild for en remote

Scriptet venter på en remote, der aldrig dukker op. Tjek, at navnet og store og små bogstaver passer præcist, og at remoten ligger i ReplicatedStorage og ikke i ServerStorage eller ServerScriptService, som klienterne ikke kan se.

Serveren får de forkerte værdier, forskudt med én

LocalScriptet sendte selve spilleren med, som i remote:FireServer(player, 5). Roblox tilføjer allerede afsenderen som første parameter, så serveren ser (player, player, 5). Kald remote:FireServer(5).

Der sker ingenting, når jeg kalder en remote

Tjek, at hvert kald kommer fra den rigtige side: FireServer og InvokeServer virker kun fra klientkode, og FireClient, FireAllClients og InvokeClient kun fra et server-Script. Et LocalScript kører aldrig i ServerScriptService, ServerStorage eller direkte i Workspace; læg det i StarterPlayerScripts, StarterGui, StarterCharacterScripts eller StarterPack. Søg derefter i Output efter en fejl inde i handleren.

Remote event invocation discarded

Der kom beskeder til en RemoteEvent, der ikke havde en forbundet handler, og køen blev fuld. Som regel går scriptet med handleren ned med en fejl før linjen med :Connect, er slået fra eller hænger og venter på noget, der aldrig bliver indlæst. Forbind handlere tidligt i scriptet.

Det virker for mig, men andre spillere kan ikke se ændringen

Ændringen er lavet på klienten, i et LocalScript eller i en OnClientEvent-handler. Lav den i en OnServerEvent-handler på serveren.

InvokeServer returnerer aldrig

Enten har intet script sat OnServerInvoke (Roblox holder kald i kø, indtil det sættes), eller callbacket hænger på noget, der yielder, for eksempel WaitForChild eller en forespørgsel til et datalager. Tilføj print i starten og slutningen af callbacket for at se, hvor det stopper.

Lav det med RoCode

RoCode kan også sætte det her op, direkte i det place, du har åbent. RoCode er en AI-agent, der arbejder via et plugin til Roblox Studio, så den opretter remotes og scripts i din Explorer i stedet for at give dig kode, som du skal indsætte.

Du skriver

Lad spillerne male parts i mappen Paintable med et klik. Brug en RemoteEvent, og hold tjekkene på serveren: kun parts fra den mappe, højst 30 studs væk og ikke mere end nogle få malinger i sekundet.

RoCode gør
  • Gennemser som regel først dit place med Search Game og Search Scripts efter en færdig Remotes-mappe eller handler og bruger dine mapper, hvis de findes
  • Opretter en RemoteEvent i ReplicatedStorage med Create Instance og skriver server-Scriptet og LocalScriptet med Create Script
  • Tjekker før afslutningen kompileringen af hvert script med Check Script inde i Studio. Det fanger kompileringsfejl, ikke logiske fejl: den tjekker ikke typer, kører ikke en linter og kører ikke din kode
  • Sender ændringerne i pakker, og hver pakke er et fortrydelsespunkt i Studios historik

Med plugin 3.9 eller nyere kan RoCode køre en kort playtest og læse fejlene, og med plugin 3.9.11 eller nyere kan den styre en testfigur, men den klikker ikke på parts i 3D-vinduet. Tryk selv på Play, og prøv at bryde tjekkene, for eksempel ved at male en part fra den anden ende af kortet. Hvis der opstod en fejl, kan Check Output læse Server- og Client-linjerne fra din seneste playtest. De fleste spilsystemer kommunikerer via sådanne remotes, så du møder dem igen, når du bygger et spil system for system med RoCode. Sådan forbinder RoCode til Studio.

Ofte stillede spørgsmål

Hvad betyder securing the client-server boundary i Roblox?

Sådan hedder en side i Robloxs dokumentation om sikkerhed for remotes, og idéen er enkel: alt, hvad klienten sender via en RemoteEvent eller RemoteFunction, kan komme fra en exploiter, så serveren tjekker det, før den handler. Tjek hvert arguments type, hold tal inden for rimelige grænser, tjek at spilleren lige nu har lov til at gøre det, og begræns, hvor ofte hver spiller kan kalde remoten. Tjeklisten ovenfor viser hvert tjek i kode.

Er det sikkert at bruge RemoteFunction?

InvokeServer er lige så sikker som dit callback på serveren: tjek dets argumenter, og begræns hyppigheden som for enhver RemoteEvent. Den risikable retning er InvokeClient, fordi en klient, der får en fejl, går eller aldrig returnerer en værdi, ødelægger eller fastlåser kaldet på serveren.

Kan exploitere se og kalde mine remotes?

Ja. Alt, hvad der ligger i ReplicatedStorage, når ud til hver klient, og en modificeret klient kan kalde enhver remote med alle mulige argumenter. At omdøbe eller skjule remotes gør dem ikke sikre; det gør tjek af hvert argument på serveren.

Kan én klient sende en RemoteEvent til en anden klient?

Ikke direkte. Send den til serveren, tjek den der, og brug derefter FireClient eller FireAllClients.

Hvor ofte kan man kalde en RemoteEvent?

Robloxs dokumentation angiver en grænse på cirka 500 forespørgsler i sekundet pr. klient for RemoteEvent- og UnreliableRemoteEvent-beskeder sendt til serveren, fælles for alle remotes af samme type. Hold dig et godt stykke under den, og giv hver handler sin egen grænse pr. spiller.

Når FireAllClients spillere, der kommer senere?

Nej. Den når de spillere, der er forbundet i det øjeblik. Til tilstand, som dem, der kommer for sent, har brug for, sætter du en attribut eller et value-objekt på serveren.

Hvad er forskellen på RemoteEvent og BindableEvent?

En RemoteEvent går mellem server og klient. En BindableEvent forbinder scripts på samme side, for eksempel to server-scripts.

Kilder og videre læsning

Sådan blev koden tjekket: hvert script på denne side gennemgår streng Luau-typekontrol med Roblox API-definitionerne (luau-lsp, 20. november 2026). Typekontrollen fanger fejl i API-navne og forkerte typer, men ikke fejl i spillogikken, så test alt i Studio, før du udgiver.

Prøv RoCode i dit eget spil.

Gratis credits hver dag, intet kort. Installér pluginet, beskriv en funktion, og se hvad der dukker op i Studio.