Tutorial · Grunnleggende scripting

RemoteEvent i Roblox: fra klient til server og tilbake

Et LocalScript kan ikke endre det andre spillere ser, og et server-Script kan ikke nå inn på én spillers skjerm. Meldinger mellom dem sendes med RemoteEvents. I denne guiden bygger vi de tre mønstrene du oftest trenger, en RemoteFunction som returnerer et svar, og sjekkene på serveren som hindrer en modifisert klient i å misbruke dem.

Oppdatert 20. november 202618 min lesingSkrevet av

Kort fortalt

En RemoteEvent er et objekt som som regel ligger i ReplicatedStorage og sender meldinger over grensen mellom klient og server. Et LocalScript kaller FireServer, og serveren mottar meldingen i OnServerEvent, der Player-en som sendte den, er lagt til som første argument. Serveren kaller FireClient(player, ...) eller FireAllClients(...), og LocalScripts mottar meldingen i OnClientEvent.

  • Bruk bare RemoteFunction (InvokeServer og OnServerInvoke) når klienten trenger et svar. Unngå InvokeClient: en klient som fikk en feil, gikk ut eller aldri returnerte en verdi, ødelegger kallet på serveren.
  • Stol aldri på det klienten sender. Sjekk på serveren type, intervall og eierskap for hvert argument, avstanden til spilleren og hvor ofte den kaller remoten.
  • Funksjoner, metatabeller og objekter som den andre siden ikke kan se, overlever ikke overføringen. UnreliableRemoteEvent kan miste meldinger eller endre rekkefølgen deres og forkaster alle data over 1000 bytes.
På denne siden
  1. Hvorfor remotes
  2. Oppsett av remotes
  3. 1. Fra klient til server
  4. 2. Fra server til klient
  5. 3. Fra server til alle
  6. RemoteFunction
  7. Sjekkliste
  8. Hva du ikke kan sende
  9. Returnerer nil?
  10. UnreliableRemoteEvent
  11. Rekkefølge og grenser
  12. Hva du skal velge
  13. Common errors
  14. Med RoCode
  15. Ofte stilte spørsmål
  16. Kilder og videre lesing

Hvorfor RemoteEvents trengs

IllustrasjonHvert klikk ber serveren male en part, så den nye fargen synes på begge spillernes skjermer.

Ethvert Roblox-spill kjører som én server pluss én klient for hver spiller. Serveren bestemmer: et nytt objekt eller en endret egenskap når bare ut til alle spillere når serveren lager det. En endring gjort i et LocalScript blir værende på den ene enheten, med få unntak som spillerens egen karakter, der bevegelsen styres av klienten. Derfor må klienten, når et klikk eller et tastetrykk skal endre den felles verdenen, be serveren om det, og når serveren vil at én spillers skjerm skal reagere, må den fortelle klienten det. Hvis skillet mellom Script og LocalScript er nytt for deg, les først Script vs LocalScript vs ModuleScript (på engelsk). Hvis selve scripting er nytt, start med hvordan man skriver skript i Roblox Studio.

For å krysse den grensen gir Roblox deg tre objekter:

  • RemoteEvent: en melding én vei. Avsenderen fortsetter med en gang.
  • RemoteFunction: en forespørsel som venter på svar. Koden som kaller, tar pause til den andre siden returnerer en verdi.
  • UnreliableRemoteEvent: en melding én vei som kan gå tapt eller komme i feil rekkefølge, men belaster nettverket mindre. Passer for data som endrer seg hele tiden.
Hvilket kall som utløser hvilket event
RetningAvsenderen kallerMottakeren kobler tilMottakeren får
Fra klient til serverremote:FireServer(...) i et LocalScriptremote.OnServerEvent i et ScriptPlayer-en som sendte meldingen, og deretter argumentene dine
Fra server til én klientremote:FireClient(player, ...) i et Scriptremote.OnClientEvent i et LocalScriptBare argumentene dine
Fra server til alle klienterremote:FireAllClients(...) i et Scriptremote.OnClientEvent i et LocalScriptBare argumentene dine
Klienten spør, serveren svarerremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player og deretter argumentene dine. Den som kalte, får det funksjonen returnerte

Klienter kan ikke sende meldinger direkte til hverandre. For å sende noe fra én spiller til de andre sender du det til serveren, sjekker det der og lar serveren sende det videre med FireClient eller FireAllClients. Ifølge sikkerhetsanbefalingene fra Roblox fungerer serveren her som dørvakt, ikke som en enkel videresender.

Hvor remotes skal ligge

En remote må ligge et sted der både serveren og klientene kan se den. Det vanlige stedet er ReplicatedStorage; dokumentasjonen fra Roblox nevner at Workspace eller et Tool også kan brukes i noen tilfeller. ServerStorage og ServerScriptService er bare tilgjengelige for serveren, så et LocalScript som venter på en remote derfra, venter for alltid.

  1. I Explorer holder du musen over ReplicatedStorage, klikker på knappen + og setter inn en Folder. Kall mappen Remotes.
  2. Hold musen over Remotes, klikk på +, og sett inn en RemoteEvent. Gi den et navn som beskriver formålet, for eksempel PaintRequest.
  3. Gjenta for hver remote. Denne guiden bruker to RemoteEvents (PaintRequest og Notify) og én RemoteFunction (RedeemCode).
Explorer: alt denne guiden legger til, avsnitt for 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

Skriptene i denne guiden finner remotes med WaitForChild. Den returnerer med en gang hvis remoten allerede er der, og venter hvis den ikke er det ennå, for eksempel når et serverskript lager remotes under spillet. Lag en egen remote for hver type forespørsel: da sjekker hver handler på serveren én form for argumenter, og det er mye lettere å få riktig enn med én remote til alt.

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

Den vanligste oppgaven: spilleren gjør noe på skjermen sin, og serveren avgjør hva som skjer. Her trykker spilleren Q for å velge en av fire farger og klikker eller trykker på en part for å male den. Alle ser den nye fargen, fordi serveren maler.

Klienten sender to ting: hvilken part og fargens nummer. Selve fargen sender den aldri, og i andre spill skal den på samme måte aldri sende en pris, en belønning eller en skadeverdi. En modifisert klient kan sende hva som helst, så de ekte dataene (her paletten) holder serveren, og argumentene behandler den som en forespørsel som må sjekkes.

  1. Sett inn en Folder med navnet Paintable i Workspace, og legg noen ankrede Parts i den.
  2. Sjekk at det finnes en RemoteEvent med navnet PaintRequest i ReplicatedStorage.Remotes.
  3. Sett inn 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")

-- Fargene tilhører serveren. Klienten sender bare et nummer som velger en av dem.
local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local MAX_DISTANCE = 30 -- studs mellom karakteren og parten
local COOLDOWN_SECONDS = 0.25

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

-- Den første parameteren er alltid spilleren som kalte remoten. Den legges inn av Roblox,
-- så den kan man stole på. Alt etter den kom fra klienten, og det kan man ikke stole på.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Type: en ekte part, ikke en tabell som later som den er en
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

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

	-- 3. Tillatt mål: bare parts i mappen Paintable, ingenting annet i spillet
	if not part:IsDescendantOf(paintable) then
		return
	end

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

	-- 5. Frekvensgrense: én maling per spiller hvert kvarter sekund
	local now = os.clock()
	local last = lastPaint[player]
	if last and now - last < COOLDOWN_SECONDS then
		return
	end
	lastPaint[player] = now

	part.Color = PALETTE[colourIndex]
end)

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

Hver sjekk som ikke bestås, gjør bare return. Det er ingen grunn til å forklare en juksende klient hvorfor den ble avvist.

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 ekte fargene holder serveren
local selectedColour = 1

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

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

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

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

gameProcessed er true når motoren allerede har håndtert denne inputen, som regel i brukergrensesnittet: et klikk på en knapp eller taster skrevet i et tekstfelt som chatlinjen. Takket være denne sjekken endrer ikke bokstaven Q, skrevet i en melding, fargen.

Mønster 2: fra server til én klient

Serveren sender en melding til én spiller med FireClient. Det første argumentet er Player-en den er adressert til, og handleren på klienten får bare argumentene etter den. Bruk det til alt personlig: et varsel, et belønningsvindu, en lyd bare den spilleren skal høre. Cutscene-guiden er et større gjennomgått eksempel: serveren avgjør når spilleren ser en cutscene, og sender bildene til den ene spilleren med FireClient, mens spillerens enhet flytter kameraet.

Dette paret med skript viser en velkomst når en spiller kommer inn. LocalScriptet bygger et lite banner selv, så du trenger ikke sette opp en GUI.

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 argumentet velger hvilken klient som får meldingen. Ingen andre ser den.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- I Studio kan du komme inn før dette skriptet kobler til, så vi ønsker alle som allerede er her, velkommen
for _, player in Players:GetPlayers() do
	welcome(player)
end
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 lite banner øverst på skjermen, bygd i koden
local gui = Instance.new("ScreenGui")
gui.Name = "Notifications"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

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

local messageCount = 0

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

Serveren sender meldingen ved PlayerAdded, og det kan skje før dette LocalScriptet kobler til handleren sin. Det er greit: Roblox setter RemoteEvent-meldinger som kom før handleren fantes, i kø og leverer dem i rekkefølge så snart handleren kobler til.

Klienten trenger ikke beskytte seg mot serveren: bare serverkode kan utløse OnClientEvent. Annotasjonen message: string er for typekontroll; det er ikke en sjekk under kjøring.

Mønster 3: fra server til alle klienter

FireAllClients sender den samme meldingen til hver tilkoblet spiller. Den har ikke noe Player-argument, og hver klient mottar meldingen i den samme OnClientEvent som før, så skriptet NotifyClient fra mønster 2 viser den allerede.

Dette Scriptet sier fra til alle når en spiller rører mållinjen for første gang. Legg til en ankret Part med navnet FinishLine i Workspace, og legg deretter til Scriptet i ServerScriptService.

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 kunngjort
	end
	finished[player] = true

	-- Hver tilkoblet klient kjører OnClientEvent-handleren sin med denne teksten
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

En exploiter kan utløse Touched for karakteren sin fra hvilken som helst avstand, men for en kunngjøring som vises én gang per spiller, er det harmløst. Hvis du senere gir en belønning for å nå målet, legg til sjekker på serveren før utbetalingen, for eksempel en minimumstid fra rundestart.

FireAllClients når bare spillerne som er tilkoblet i det øyeblikket. Den som kommer inn et sekund senere, ser ikke meldingen. Det passer for enkeltstående øyeblikk som en kunngjøring, en eksplosjonseffekt eller en lyd, men ikke for tilstand som en rundetimer eller spillets nåværende fase. For tilstand setter du et attributt på serveren, for eksempel ReplicatedStorage:SetAttribute("TimeLeft", 30), og leser det på klienten med GetAttribute og GetAttributeChangedSignal("TimeLeft"). Attributter replikeres til hver klient, også til spillere som kommer senere.

RemoteFunction: når klienten trenger et svar

En RemoteEvent fungerer etter prinsippet "send og glem". En RemoteFunction får den som kaller, til å vente: InvokeServer setter koden som kalte den, på pause til serverens funksjon OnServerInvoke returnerer en verdi, og gir deretter det den returnerte. Bruk den når klienten ikke kan fortsette uten et svar, for eksempel "var denne koden riktig?". Når det ikke trengs noe svar, anbefaler Roblox en RemoteEvent, fordi den ikke venter.

Eksempel: et felt der spillerne skriver inn en kampanjekode. Serveren holder kodene, sjekker teksten og returnerer to verdier: om det virket, og meldingen som skal vises.

  1. Sett inn en RemoteFunction med navnet RedeemCode i ReplicatedStorage.Remotes.
  2. Sett inn en ScreenGui med navnet CodeGui i StarterGui og inni den en TextBox med navnet CodeBox. Velg størrelse og plassering etter smak.
  3. Legg til Scriptet nedenfor i ServerScriptService og LocalScriptet inne 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

-- Kodene bor på serveren, der ingen spiller kan lese dem
local CODES: { [string]: number } = {
	LAUNCH = 100,
	THANKYOU = 50,
}
local MAX_LENGTH = 20
local COOLDOWN_SECONDS = 2

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

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

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

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

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

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

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

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

Det legger til statistikken Coins fra guiden om leaderboards. Brukte koder huskes bare til spilleren går, så i denne formen kan en spiller komme inn igjen og skrive inn den samme koden på nytt. Hvis myntene lagres, blir det gratis mynter ved hvert nye besøk: før du bruker dette i et live spill, lagre hver spillers brukte koder sammen med spillerens lagrede data i et datalager.

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 setter denne funksjonen på pause til serverens callback returnerer en verdi.
	-- pcall hindrer at LocalScriptet stopper hvis kallet feilet.
	local ok, accepted, message = pcall(function()
		return redeemCode:InvokeServer(code)
	end)

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

En RemoteFunction har nøyaktig én callback på serveren. Hvis to skript setter OnServerInvoke på den samme RemoteFunction, virker bare det siste.

Hvorfor InvokeClient er farlig

En RemoteFunction virker også den andre veien, med InvokeClient på serveren og OnClientInvoke på klienten. Dokumentasjonen fra Roblox nevner tre alvorlige risikoer:

  • Hvis klientens callback gir en feil, gir serveren også en feil.
  • Hvis spilleren går under kallet, gir InvokeClient en feil.
  • Hvis klienten aldri returnerer en verdi, venter serverskriptet for alltid.

En modifisert klient styrer sin egen callback, så en juksemaker kan med vilje fremkalle det tredje tilfellet og holde den servertråden så lenge den vil. For å oppdatere en spillers skjerm bruker du FireClient. Hvis serveren virkelig trenger informasjon fra klienten, send en RemoteEvent, la klienten svare via en annen RemoteEvent, og behandle et manglende svar som et normalt tilfelle på serveren.

Sjekk hvert argument på serveren

En exploiter kan kalle enhver RemoteEvent eller RemoteFunction så mange ganger den vil, og med alle mulige argumenter. Det eneste den ikke kan forfalske, er den første parameteren: Roblox legger selv inn Player-en som sendte meldingen. Alt som kommer etter, må sjekkes før serveren handler. Det nytter ikke å skjule remoten eller sjekke i et LocalScript, fordi juksemakeren styrer sin egen klient.

Sjekkliste for serveren
SjekkSpørsmålet serveren stillerEksempel
TypeEr det typen jeg forventer? En Instance og ikke en tabell bygd for å ligne en?typeof(part) == "Instance" and part:IsA("BasePart")
IntervallEr tallet endelig og innenfor de tillatte grensene? Har teksten en rimelig lengde?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
EierskapEier spilleren tingen, har den nok penger, har den rett til å handle med dette objektet?Tingen er i spillerens inventar; parten ligger inne i Paintable
AvstandEr spillerens karakter nær nok i serverens kopi av verdenen? Gi litt margin for lag.Høyst 30 studs fra parten
FrekvensSender denne spilleren for ofte?Cooldown per spiller eller en grense med oppsparte kall

NaN fortjener en egen advarsel. Det er et tall, så type(x) == "number" består, men enhver sammenligning med det gir false, og en sjekk som x < 0 or x > 100 slipper det gjennom. math.isfinite(x) avviser NaN og begge uendelighetene.

Husk grensen for avstandssjekken. Hver klient styrer fysikken for karakteren sin, så en exploiter kan flytte karakteren bort til målet før kallet. Sjekken stopper likevel det enkleste misbruket, der man fra ett sted handler over hele kartet. Hold målparts ankret: sikkerhetsdokumentasjonen fra Roblox nevner at en exploiter kan få network ownership over ikke-ankrede parts i nærheten og trekke dem nærmere, og det kommer rundt avstandssjekken.

Her er de samme sjekkene som et ModuleScript du kan bruke i hver remote-handler.

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

local RemoteGuard = {}

-- Et ekte tall mellom min og max. Avviser NaN og uendelig, som består
-- den vanlige sjekken type(x) == "number".
function RemoteGuard.number(value: unknown, min: number, max: number): number?
	if type(value) ~= "number" or not math.isfinite(value) then
		return nil
	end
	if value < min or value > max then
		return nil
	end
	return value
end

-- Et heltall mellom min og max, for antall, indekser og tellere
function RemoteGuard.integer(value: unknown, min: number, max: number): number?
	local n = RemoteGuard.number(value, min, max)
	if n and n % 1 == 0 then
		return n
	end
	return nil
end

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

-- En Instance av den forventede klassen inne i en container du har tillatt.
-- En tabell bygd for å ligne en Instance består ikke typeof-sjekken.
function RemoteGuard.instanceIn(value: unknown, className: string, container: Instance): Instance?
	if typeof(value) ~= "Instance" then
		return nil
	end
	if not value:IsA(className) or not value:IsDescendantOf(container) then
		return nil
	end
	return value
end

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

-- Frekvensgrense per spiller. Hver spiller kan gjøre `burst` kall på én gang og
-- får `perSecond` kall tilbake hvert sekund. Returnerer en funksjon som kalles
-- før arbeidet: den svarer true (tillatt) eller false (for ofte).
function RemoteGuard.limiter(burst: number, perSecond: number): (Player) -> boolean
	local buckets: { [Player]: { tokens: number, updated: number } } = {}

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

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

return RemoteGuard

Hold den i ServerScriptService. Kode derfra når aldri ut til klientene, så ingen kan lese sjekkene dine.

Og her er handleren fra mønster 1, skrevet om med den. Erstatt innholdet i PaintServer:

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

-- ":: any" har bare betydning for den strenge typekontrollen i Luau; under kjøring endrer det ingenting
local RemoteGuard = require(ServerScriptService:WaitForChild("RemoteGuard")) :: any

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

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

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

Begrenseren sletter spillerens oppføring når den går, så tabellen vokser ikke så lenge serveren kjører.

I våpen er disse sjekkene viktigst: la aldri klienten melde hvem som ble truffet. Remoten fra sverd-guiden har ingen argumenter i det hele tatt, og serveren finner målene selv. Våpen-guiden sender bare siktepunktet, som serveren sjekker for type, NaN og avstand før den sender sin egen stråle.

Menyer følger samme regel: send valget, ikke resultatet. I guiden om NPC-dialoger sender klienten bare nummeret på knappen som ble trykket, og serveren ser selv hva det svaret gir. Menyen fra teleport-guiden sender navnet på stedet, ikke en posisjon, og serveren finner stedet i mappen sin og sjekker hvor mange Wins det krever.

Hva du kan og ikke kan sende

Du kan sende tall, strenger, boolske verdier, Roblox-typer som Vector3, CFrame, Color3 og Enum-elementer, Instances som begge sider kan se, og tabeller av alt dette. Noen verdier endres eller forsvinner underveis:

Argumenter som ikke kommer frem slik de ble sendt
Du senderHva som skjer
En funksjonDen andre siden får nil
En tabell med en metatabellMetatabellen går tapt sammen med alt tabellen bare hadde via den
En tabell der tall- og strengnøkler er blandetRoblox fraråder det: send et rent array eller en ren ordbok
En tabell med nil-verdier inniUnngå det: Roblox fraråder nil på enhver indeks
En tabell med nøkler av typen Instance, userdata eller functionSlike nøkler blir til strenger
En Instance som mottakeren ikke kan se, for eksempel fra ServerStorage eller laget i et LocalScriptDen andre siden får nil
Enhver tabellMottakeren får en kopi, ikke den samme tabellen

En god vane: send identifikatorer, ikke objekter eller verdier. Et navn på en ting, et nummer på et valg, en part som serveren kan finne og sjekke. Deretter jobber serveren med sine egne data.

Hvorfor RemoteFunction returnerer nil

Hvis InvokeServer gir deg nil, gå gjennom disse punktene i rekkefølge:

  1. En vei uten returverdi. Hver utgang fra OnServerInvoke må returnere noe. En tom return i en tidlig sjekk sender nil tilbake.
  2. return inne i en nestet funksjon. return inne i pcall(function() ... end), en :Connect-handler eller task.spawn forlater bare den indre funksjonen. Lagre resultatet, for eksempel local ok, data = pcall(...), og returner deretter data fra selve callbacken.
  3. En verdi som ikke kan krysse grensen. En funksjon eller en Instance som klienten ikke kan se (for eksempel alt i ServerStorage), kommer frem som nil. Med instance streaming slått på har en part som serveren nettopp laget, kanskje ikke nådd klienten ennå når funksjonen returnerer.
  4. Et annet skript satte callbacken. Bare den siste tilordningen av OnServerInvoke virker. Søk etter navnet på remoten i skriptene dine.

Hvis kallet ikke returnerer i det hele tatt, har ingen skript satt OnServerInvoke ennå (Roblox holder kall i kø til den settes), eller callbacken henger, for eksempel på WaitForChild for noe som aldri dukker opp.

UnreliableRemoteEvent: for konstante engangsoppdateringer

En UnreliableRemoteEvent har de samme metodene og eventene som en RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent og OnClientEvent. Forskjellen er at Roblox verken garanterer levering eller rekkefølge. En melding kan bli forkastet uten å bli sendt på nytt når:

  • den går tapt underveis eller venter for lenge i et overbelastet nettverk
  • dataene er større enn 1000 bytes
  • klienten sender oftere enn grensen (det overskytende forkastes i stedet for å bli utsatt)
  • det ikke er koblet til noen handler når den kommer (den kastes i stedet for å bli satt i kø)

Meldinger kan også komme i feil rekkefølge, og rekkefølgen deres har ingenting med RemoteEvents eller RemoteFunctions å gjøre. Bruk den når bare den nyeste verdien betyr noe og neste oppdatering kommer om en brøkdel av et sekund: hvor spilleren sikter, posisjonen til en kosmetisk effekt, en verdi som endrer seg hver frame. Hvis rekkefølgen betyr noe, legg et løpenummer eller et tidsstempel i hver melding, og ignorer alt som er eldre enn det sist behandlede.

Bruk den aldri til noe som skal skje nøyaktig én gang, for eksempel et kjøp, skade, en belønning eller starten på en runde. Og sjekk argumentene på serveren akkurat som ved en RemoteEvent.

Leveringsrekkefølge og frekvensgrenser

Leveringsgarantiene fra Roblox gjelder én tilkobling i én retning: fra serveren til én klient eller fra én klient til serveren.

  • RemoteEvents er pålitelige og ordnede. Tapte meldinger sendes på nytt så lenge mottakeren er tilkoblet, og meldinger kommer frem i rekkefølgen du sendte dem, selv på tvers av ulike RemoteEvents. Hvis serveren sender A, så B, så A til en spiller, får den spilleren A, B, A.
  • Rekkefølgen gjelder tidspunktet handlerne starter. Hvis en handler yielder, for eksempel med task.wait eller WaitForChild, kan neste melding begynne å bli behandlet før den første er ferdig.
  • RemoteFunctions og RemoteEvents er ikke ordnet i forhold til hverandre. Hvis koden din er avhengig av en streng rekkefølge, send relaterte meldinger via samme type remote, eller legg til ditt eget løpenummer.
  • Endringer av egenskaper og attributter er ikke ordnet i forhold til remotes. Hvis serveren endrer en egenskap og deretter kaller en remote, kan klienten se hvilken som helst av de to først. Lytt etter selve endringen, for eksempel med GetPropertyChangedSignal, i stedet for å regne med at den allerede har kommet.
  • Handleren finnes ikke ennå. RemoteEvent-meldinger står i kø til en handler kobler til. Køen har grenser: når den er full, forkastes de neste meldingene, og i Output vises feilen Remote event invocation discarded.
  • En spiller som går, mister alle meldinger som ikke har kommet frem ennå.

Frekvensgrense. RemoteEvent- og UnreliableRemoteEvent-meldinger fra klient til server er begrenset til omtrent 500 forespørsler i sekundet per klient ifølge dokumentasjonen per 30. september 2026. Grensen er felles for alle remotes av samme type, så å dele én travel remote i ti hever den ikke. Over grensen behandles RemoteEvent-meldinger senere og beholder rekkefølgen, mens UnreliableRemoteEvent-meldinger forkastes. Motorens grense hindrer ikke én spiller i å kalle remoten din 50 ganger i sekundet, så hver handler som endrer noe, trenger fortsatt sin egen grense per spiller.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent eller et attributt?

Slik velger du hvordan klient og server kommuniserer
BrukTil hvaEksempelHva du må være oppmerksom på
RemoteEventMeldinger én vei som må komme frem, og i rekkefølgeKlient: "mal denne parten". Server: "vis dette varselet"Sjekk hvert argument på serveren
RemoteFunction med InvokeServerKlienten må ha et svar før den kan fortsetteSkriv inn en kampanjekode, bekreft et kjøpDen som kaller, venter; hver vei må returnere en verdi
RemoteFunction med InvokeClientNesten aldriBruk FireClient i stedetEn klient som får en feil, går eller ikke svarer, ødelegger eller låser kallet på serveren
UnreliableRemoteEventHyppige oppdateringer der bare den siste betyr noeSikteretning, kosmetiske effekterMeldinger går tapt eller bytter rekkefølge; datagrense på 1000 bytes
Et attributt eller et value-objekt satt av serverenFelles tilstand som alltid skal kunne ses, også av spillere som kommer senereRundetimer, spillets fase, om en dør er åpenBare serverens endringer når ut til alle; klienter lytter med GetAttributeChangedSignal eller Changed
BindableEventKommunikasjon mellom skript på samme sideEtt serverskript forteller et annet at runden er overGår ikke mellom server og klient

Et fullstendig eksempel på hvordan RemoteFunction og sjekker jobber sammen der spillere betaler, finner du i guiden slik lager du en butikk-GUI. Når det gjelder raden om attributter, setter serverskriptet fra dør-guiden attributtet Open på hver dør hver gang den beveger seg, slik at ethvert LocalScript kan reagere på det.

Vanlige feil og løsninger

De fleste problemer med remotes kan ses i Output-vinduet (åpne det fra menyen Window eller fanen Script). Se der først, og finn deretter symptomet ditt nedenfor. Guiden om skriptfeil går gjennom vanlige feilmeldinger mer i detalj.

Infinite yield possible ved WaitForChild for en remote

Skriptet venter på en remote som aldri dukker opp. Sjekk at navnet og store og små bokstaver stemmer nøyaktig, og at remoten ligger i ReplicatedStorage og ikke i ServerStorage eller ServerScriptService, som klientene ikke kan se.

Serveren får feil verdier, forskjøvet med én

LocalScriptet sendte med selve spilleren, som i remote:FireServer(player, 5). Roblox legger allerede til avsenderen som første parameter, så serveren ser (player, player, 5). Kall remote:FireServer(5).

Ingenting skjer når jeg kaller en remote

Sjekk at hvert kall kommer fra riktig side: FireServer og InvokeServer virker bare fra klientkode, og FireClient, FireAllClients og InvokeClient bare fra et server-Script. Et LocalScript kjører aldri i ServerScriptService, ServerStorage eller direkte i Workspace; legg det i StarterPlayerScripts, StarterGui, StarterCharacterScripts eller StarterPack. Søk deretter i Output etter en feil inne i handleren.

Remote event invocation discarded

Det kom meldinger til en RemoteEvent som ikke hadde noen tilkoblet handler, og køen ble full. Som regel krasjer skriptet med handleren med en feil før linjen med :Connect, er slått av eller henger og venter på noe som aldri blir lastet. Koble til handlere tidlig i skriptet.

Det virker for meg, men andre spillere ser ikke endringen

Endringen er gjort på klienten, i et LocalScript eller i en OnClientEvent-handler. Gjør den i en OnServerEvent-handler på serveren.

InvokeServer returnerer aldri

Enten har ingen skript satt OnServerInvoke (Roblox holder kall i kø til den settes), eller callbacken henger på noe som yielder, for eksempel WaitForChild eller en forespørsel til et datalager. Legg til print i starten og slutten av callbacken for å se hvor den stopper.

Lag det med RoCode

RoCode kan også sette opp dette, direkte i placen du har åpen. RoCode er en AI-agent som jobber via en plugin for Roblox Studio, så den lager remotes og skript i Explorer hos deg i stedet for å gi deg kode du må lime inn.

Du skriver

La spillerne male parts i mappen Paintable med et klikk. Bruk en RemoteEvent, og hold sjekkene på serveren: bare parts fra den mappen, høyst 30 studs unna og ikke mer enn noen få malinger i sekundet.

RoCode gjør
  • Går som regel først gjennom placen din med Search Game og Search Scripts etter en ferdig Remotes-mappe eller handler, og bruker mappene dine hvis de finnes
  • Lager en RemoteEvent i ReplicatedStorage med Create Instance og skriver server-Scriptet og LocalScriptet med Create Script
  • Sjekker før den avslutter kompileringen av hvert skript med Check Script inne i Studio. Det fanger kompileringsfeil, ikke logiske feil: den sjekker ikke typer, kjører ikke en linter og kjører ikke koden din
  • Sender endringene i pakker, og hver pakke er et angrepunkt i historikken i Studio

Med plugin 3.9 eller nyere kan RoCode kjøre en kort playtest og lese feilene, og med plugin 3.9.11 eller nyere kan den styre en testfigur, men den klikker ikke på parts i 3D-vinduet. Trykk Play selv, og prøv å bryte sjekkene, for eksempel ved å male en part fra den andre enden av kartet. Hvis det oppsto en feil, kan Check Output lese Server- og Client-linjene fra den siste playtesten din. De fleste spillsystemer kommuniserer via slike remotes, så du møter dem igjen når du bygger et spill system for system med RoCode. Slik kobler RoCode seg til Studio.

Ofte stilte spørsmål

Hva betyr securing the client-server boundary i Roblox?

Det er navnet på en side i dokumentasjonen fra Roblox om sikkerhet for remotes, og ideen er enkel: alt klienten sender via en RemoteEvent eller RemoteFunction, kan komme fra en exploiter, så serveren sjekker det før den handler. Sjekk typen til hvert argument, hold tall innenfor rimelige grenser, sjekk at spilleren akkurat nå har lov til å gjøre det, og begrens hvor ofte hver spiller kan kalle remoten. Sjekklisten ovenfor viser hver sjekk i kode.

Er det trygt å bruke RemoteFunction?

InvokeServer er like trygg som callbacken din på serveren: sjekk argumentene, og begrens frekvensen som for enhver RemoteEvent. Den risikable retningen er InvokeClient, fordi en klient som får en feil, går eller aldri returnerer en verdi, ødelegger eller låser kallet på serveren.

Kan exploitere se og kalle remotene mine?

Ja. Alt som ligger i ReplicatedStorage, når ut til hver klient, og en modifisert klient kan kalle enhver remote med alle mulige argumenter. Å gi remotes nye navn eller skjule dem gjør dem ikke trygge; det gjør sjekk av hvert argument på serveren.

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

Ikke direkte. Send den til serveren, sjekk den der, og bruk deretter FireClient eller FireAllClients.

Hvor ofte kan man kalle en RemoteEvent?

Dokumentasjonen fra Roblox oppgir en grense på omtrent 500 forespørsler i sekundet per klient for RemoteEvent- og UnreliableRemoteEvent-meldinger sendt til serveren, felles for alle remotes av samme type. Hold deg godt under den, og gi hver handler sin egen grense per spiller.

Når FireAllClients spillere som kommer senere?

Nei. Den når spillerne som er tilkoblet i det øyeblikket. For tilstand som de som kommer for sent, trenger, setter du et attributt eller et value-objekt på serveren.

Hva er forskjellen på RemoteEvent og BindableEvent?

En RemoteEvent går mellom server og klient. En BindableEvent kobler sammen skript på samme side, for eksempel to serverskript.

Kilder og videre lesing

Slik ble koden sjekket: hvert skript på denne siden går gjennom streng Luau-typesjekk med Roblox API-definisjonene (luau-lsp, 20. november 2026). Typesjekken fanger feil i API-navn og feil typer, men ikke feil i spillogikken, så test alt i Studio før du publiserer.

Prøv RoCode i ditt eget spill.

Gratis credits hver dag, uten kort. Installer pluginen, beskriv en funksjon og se hva som dukker opp i Studio.