Poradnik · Podstawy skryptowania

RemoteEvent w Roblox: od klienta do serwera i z powrotem

LocalScript nie może zmienić tego, co widzą inni gracze, a serwerowy Script nie może sięgnąć do ekranu jednego gracza. Wiadomości między nimi przekazują RemoteEvent. W tym poradniku zbudujemy trzy schematy, których będziesz potrzebować najczęściej, RemoteFunction, która zwraca odpowiedź, i serwerowe sprawdzenia, które nie pozwalają zmodyfikowanemu klientowi ich nadużywać.

Zaktualizowano 20 listopada 202617 min czytaniaAutor:

W skrócie

RemoteEvent to obiekt, który zwykle leży w ReplicatedStorage i przekazuje wiadomości przez granicę między klientem a serwerem. LocalScript wywołuje FireServer, a serwer dostaje wiadomość w OnServerEvent, gdzie jako pierwszy argument dodany jest Player, który ją wysłał. Serwer wywołuje FireClient(player, ...) albo FireAllClients(...), a LocalScripty dostają wiadomość w OnClientEvent.

  • Używaj RemoteFunction (InvokeServer i OnServerInvoke) tylko wtedy, gdy klient potrzebuje odpowiedzi. Unikaj InvokeClient: klient, u którego wystąpił błąd, który wyszedł albo nigdy nie zwrócił wartości, psuje wywołanie na serwerze.
  • Nigdy nie ufaj temu, co wysyła klient. Na serwerze sprawdzaj typ, zakres i przynależność każdego argumentu, odległość do gracza i to, jak często wywołuje remote.
  • Funkcje, metatabele i obiekty, których nie widzi druga strona, nie przetrwają przesyłki. UnreliableRemoteEvent może gubić wiadomości albo zmieniać ich kolejność i odrzuca wszelkie dane większe niż 1000 bajtów.
Na tej stronie
  1. Po co są remote’y
  2. Ustawienie remote’ów
  3. 1. Od klienta do serwera
  4. 2. Od serwera do klienta
  5. 3. Od serwera do wszystkich
  6. RemoteFunction
  7. Lista sprawdzeń
  8. Czego nie wyślesz
  9. Zwraca nil?
  10. UnreliableRemoteEvent
  11. Kolejność i limity
  12. Co wybrać
  13. Common errors
  14. Z RoCode
  15. Najczęstsze pytania
  16. Źródła i dalsza lektura

Po co są RemoteEvent

IlustracjaKażde kliknięcie prosi serwer o pomalowanie partu, więc nowy kolor widać na ekranach obu graczy.

Każda gra Roblox działa jako jeden serwer plus po jednym kliencie na każdego gracza. Serwer jest tu głównym: nowy obiekt albo zmiana właściwości dociera do wszystkich graczy tylko wtedy, gdy robi ją serwer. Zmiana zrobiona w LocalScript zostaje na jednym urządzeniu, z nielicznymi wyjątkami w rodzaju własnej postaci gracza, której ruchem steruje jego klient. Dlatego gdy kliknięcie albo naciśnięcie klawisza ma zmienić wspólny świat, klient musi poprosić serwer, a gdy serwer chce, żeby zareagował ekran jednego gracza, musi o tym powiadomić klienta. Jeśli podział na Script i LocalScript jest dla ciebie nowy, najpierw przeczytaj Script vs LocalScript vs ModuleScript (po angielsku). Jeśli nowe jest samo skryptowanie, zacznij od tego, jak pisać skrypty w Roblox Studio.

Do przekraczania tej granicy Roblox daje trzy obiekty:

  • RemoteEvent: wiadomość w jedną stronę. Nadawca od razu pracuje dalej.
  • RemoteFunction: żądanie, które czeka na odpowiedź. Wywołujący kod stoi na pauzie, dopóki druga strona nie zwróci wartości.
  • UnreliableRemoteEvent: wiadomość w jedną stronę, która może się zgubić albo przyjść nie po kolei, za to mniej obciąża sieć. Pasuje do danych, które zmieniają się bez przerwy.
Które wywołanie uruchamia który event
KierunekNadawca wywołujeOdbiorca podłącza się doOdbiorca dostaje
Od klienta do serweraremote:FireServer(...) w LocalScriptremote.OnServerEvent w ScriptPlayer, który wysłał wiadomość, potem twoje argumenty
Od serwera do jednego klientaremote:FireClient(player, ...) w Scriptremote.OnClientEvent w LocalScriptTylko twoje argumenty
Od serwera do wszystkich klientówremote:FireAllClients(...) w Scriptremote.OnClientEvent w LocalScriptTylko twoje argumenty
Klient pyta, serwer odpowiadaremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player, potem twoje argumenty. Wywołujący dostaje to, co zwróciła funkcja

Klienci nie mogą wysyłać wiadomości bezpośrednio do siebie. Żeby przekazać coś od jednego gracza pozostałym, wyślij to na serwer, sprawdź tam i niech serwer prześle dalej przez FireClient albo FireAllClients. Według zaleceń Roblox o bezpieczeństwie serwer działa tu jak strażnik, a nie zwykły przekaźnik.

Gdzie trzymać remote’y

Remote musi leżeć tam, gdzie widzą go i serwer, i klienci. Zwykłe miejsce to ReplicatedStorage; w dokumentacji Roblox zaznaczono, że w niektórych przypadkach pasują też Workspace albo Tool. ServerStorage i ServerScriptService są dostępne tylko dla serwera, więc LocalScript, który czeka na remote stamtąd, będzie czekać w nieskończoność.

  1. W Explorerze najedź kursorem na ReplicatedStorage, kliknij przycisk + i wstaw Folder. Nazwij folder Remotes.
  2. Najedź kursorem na Remotes, kliknij + i wstaw RemoteEvent. Zmień jego nazwę tak, żeby opisywała przeznaczenie, na przykład PaintRequest.
  3. Powtórz dla każdego remote’a. W tym poradniku używamy dwóch RemoteEvent (PaintRequest i Notify) i jednej RemoteFunction (RedeemCode).
Explorer: wszystko, co dodaje ten poradnik, sekcja po sekcji
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

Skrypty w tym poradniku znajdują remote’y przez WaitForChild. Zwraca wynik od razu, jeśli remote już jest na miejscu, i czeka, jeśli jeszcze go nie ma, na przykład gdy serwerowy skrypt tworzy remote’y w trakcie gry. Zakładaj osobny remote na każdy rodzaj żądania: wtedy każdy serwerowy handler sprawdza jeden kształt argumentów, a zrobić to poprawnie jest dużo łatwiej niż z jednym remote’em na wszystko.

Schemat 1: od klienta do serwera, ze sprawdzeniem na serwerze

Najczęstsze zadanie: gracz robi coś na swoim ekranie, a serwer decyduje, co się stanie. Tutaj gracz naciska Q, żeby wybrać jeden z czterech kolorów, i klika albo dotyka part, żeby go pomalować. Nowy kolor widzą wszyscy, bo maluje serwer.

Klient wysyła dwie rzeczy: który part i numer koloru. Samego koloru nie wysyła nigdy i w innych grach tak samo nie powinien wysyłać ceny, nagrody ani wielkości obrażeń. Zmodyfikowany klient może wysłać cokolwiek, więc prawdziwe dane (tutaj paletę) przechowuje serwer, a argumenty traktuje jako żądanie, które trzeba sprawdzić.

  1. W Workspace wstaw Folder o nazwie Paintable i włóż do niego kilka zakotwiczonych Partów.
  2. Sprawdź, czy w ReplicatedStorage.Remotes jest RemoteEvent o nazwie PaintRequest.
  3. Wstaw Script o nazwie PaintServer do ServerScriptService i LocalScript o nazwie PaintClient do StarterPlayer, StarterPlayerScripts, z kodem poniżej.
Script w ServerScriptService o nazwie 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")

-- Kolory należą do serwera. Klient wysyła tylko numer, który wybiera jeden z nich.
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 -- studów między postacią a partem
local COOLDOWN_SECONDS = 0.25

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

-- Pierwszy parametr to zawsze gracz, który wywołał remote. Wstawia go Roblox,
-- więc można mu ufać. Wszystko po nim przyszło od klienta i temu ufać nie wolno.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Typ: prawdziwy part, a nie tabela, która go udaje
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Zakres: liczba całkowita od 1 do 4. NaN i nieskończoność też odpadają tutaj.
	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. Dozwolony cel: tylko party w folderze Paintable, nic więcej w grze
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Odległość: postać gracza musi być blisko partu
	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. Limit częstotliwości: jedno malowanie na gracza co ćwierć sekundy
	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)

Każde nieudane sprawdzenie po prostu robi return. Nie ma po co tłumaczyć oszukującemu klientowi, dlaczego dostał odmowę.

LocalScript w StarterPlayerScripts o nazwie 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 -- prawdziwe kolory przechowuje serwer
local selectedColour = 1

-- Promień może trafiać tylko w party w folderze 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 -- klawisz albo kliknięcie poszły do czatu albo przycisku
	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
			-- Prosimy, a nie rozkazujemy: czy malować, decyduje serwer
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed jest true, gdy silnik już obsłużył to wejście, zwykle w interfejsie: kliknięcie przycisku albo klawisze wpisane w polu tekstowym, na przykład w linii czatu. Dzięki temu sprawdzeniu litera Q wpisana w wiadomości nie zmienia koloru.

Schemat 2: od serwera do jednego klienta

Serwer wysyła wiadomość jednemu graczowi przez FireClient. Pierwszy argument to Player, do którego jest skierowana, a handler na kliencie dostaje tylko argumenty po nim. Używaj tego do wszystkiego, co osobiste: powiadomienie, okno z nagrodą, dźwięk, który ma słyszeć tylko ten gracz. Poradnik o cutscenkach to większy omówiony przykład: serwer decyduje, kiedy gracz zobaczy cutscenkę, i wysyła jej klatki temu jednemu graczowi przez FireClient, a kamerą porusza jego urządzenie.

Ta para skryptów pokazuje powitanie, gdy gracz wchodzi. LocalScript sam buduje mały baner, więc nie trzeba ustawiać GUI.

Script w ServerScriptService o nazwie WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent

local function welcome(player: Player)
	-- Pierwszy argument wybiera, który klient dostanie wiadomość. Nikt inny jej nie zobaczy.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- W Studio możesz wejść, zanim ten skrypt się podłączy, więc witamy wszystkich, którzy już są
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript w StarterPlayerScripts o nazwie NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Mały baner na górze ekranu, zbudowany w kodzie
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

-- Tu nie ma parametru player: serwer już wybrał, kto dostanie wiadomość
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 -- chowamy, jeśli nie zastąpiła go nowsza wiadomość
			label.Visible = false
		end
	end)
end)

Serwer wysyła wiadomość przy PlayerAdded, a to może się zdarzyć, zanim ten LocalScript podłączy swój handler. To w porządku: Roblox ustawia w kolejce wiadomości RemoteEvent, które przyszły przed pojawieniem się handlera, i dostarcza je po kolei, gdy tylko handler się podłączy.

Klient nie musi bronić się przed serwerem: wywołać OnClientEvent może tylko kod serwerowy. Adnotacja message: string jest dla sprawdzania typów; to nie jest sprawdzenie w trakcie działania.

Schemat 3: od serwera do wszystkich klientów

FireAllClients wysyła tę samą wiadomość każdemu podłączonemu graczowi. Nie ma argumentu Player, a każdy klient dostaje wiadomość w tym samym OnClientEvent co wcześniej, więc skrypt NotifyClient ze schematu 2 już ją pokazuje.

Ten Script ogłasza wszystkim, gdy gracz pierwszy raz dotknie linii mety. Dodaj do Workspace zakotwiczony Part o nazwie FinishLine, potem dodaj Script do ServerScriptService.

Script w ServerScriptService o nazwie 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 -- nie gracz albo już ogłoszony
	end
	finished[player] = true

	-- Każdy podłączony klient uruchamia swój handler OnClientEvent z tym tekstem
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

Exploiter może wywołać Touched dla swojej postaci z dowolnej odległości, ale dla ogłoszenia, które pokazuje się raz na gracza, jest to nieszkodliwe. Jeśli później będziesz dawać nagrodę za metę, dodaj serwerowe sprawdzenia przed wydaniem, na przykład minimalny czas od startu rundy.

FireAllClients dociera tylko do graczy podłączonych w tej chwili. Ten, kto wejdzie sekundę później, wiadomości już nie zobaczy. To pasuje do jednorazowych momentów, takich jak ogłoszenie, efekt wybuchu albo dźwięk, ale nie pasuje do stanu w rodzaju timera rundy albo bieżącej fazy gry. Dla stanu ustaw na serwerze atrybut, na przykład ReplicatedStorage:SetAttribute("TimeLeft", 30), i czytaj go na kliencie przez GetAttribute i GetAttributeChangedSignal("TimeLeft"). Atrybuty replikują się do każdego klienta, łącznie z graczami, którzy weszli później.

RemoteFunction: gdy klient potrzebuje odpowiedzi

RemoteEvent działa na zasadzie „wyślij i zapomnij”. RemoteFunction każe wywołującemu czekać: InvokeServer pauzuje kod, który go wywołał, dopóki serwerowa funkcja OnServerInvoke nie zwróci wartości, a potem oddaje to, co zwróciła. Używaj jej, gdy klient nie może iść dalej bez odpowiedzi, na przykład „czy ten kod był poprawny?”. Gdy odpowiedź nie jest potrzebna, Roblox zaleca RemoteEvent, bo nie czeka.

Przykład: pole, w którym gracze wpisują kod promocyjny. Serwer przechowuje kody, sprawdza tekst i zwraca dwie wartości: czy zadziałało i wiadomość do pokazania.

  1. W ReplicatedStorage.Remotes wstaw RemoteFunction o nazwie RedeemCode.
  2. W StarterGui wstaw ScreenGui o nazwie CodeGui, a do niego TextBox o nazwie CodeBox. Rozmiar i miejsce wybierz według uznania.
  3. Dodaj Script poniżej do ServerScriptService, a LocalScript do CodeBox.
Script w ServerScriptService o nazwie RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Kody żyją na serwerze, gdzie żaden gracz nie może ich przeczytać
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 } = {}

-- Przypisujemy przez =. OnServerInvoke to callback, a nie event, do którego robi się 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)

Dodaje do statystyki Coins z poradnika o leaderboardzie. Użyte kody są pamiętane tylko do wyjścia gracza, więc w tej postaci gracz może wejść ponownie i wpisać ten sam kod znowu. Jeśli monety się zapisują, to darmowe monety przy każdym ponownym wejściu: zanim użyjesz tego w opublikowanej grze, trzymaj użyte kody każdego gracza razem z jego zapisanymi danymi w magazynie danych.

LocalScript w TextBox CodeBox o nazwie 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 pauzuje tę funkcję, dopóki callback serwera nie zwróci wartości.
	-- pcall nie pozwala LocalScript się zatrzymać, jeśli wywołanie się nie udało.
	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)

RemoteFunction ma dokładnie jeden serwerowy callback. Jeśli dwa skrypty ustawiają OnServerInvoke tej samej RemoteFunction, działa tylko ostatni.

Czym grozi InvokeClient

RemoteFunction działa też w drugą stronę, z InvokeClient na serwerze i OnClientInvoke na kliencie. Dokumentacja Roblox wymienia trzy poważne ryzyka:

  • Jeśli callback klienta rzuci błąd, serwer też rzuci błąd.
  • Jeśli gracz wyjdzie w trakcie wywołania, InvokeClient rzuci błąd.
  • Jeśli klient nigdy nie zwróci wartości, serwerowy skrypt będzie czekać w nieskończoność.

Zmodyfikowany klient kontroluje swój callback, więc oszust może celowo wywołać trzeci przypadek i trzymać ten serwerowy wątek, jak długo zechce. Żeby zaktualizować ekran gracza, używaj FireClient. Jeśli serwer naprawdę potrzebuje informacji od klienta, wyślij RemoteEvent, niech klient odpowie przez inny RemoteEvent, a brak odpowiedzi traktuj na serwerze jako zwykły przypadek.

Sprawdzaj każdy argument na serwerze

Exploiter może wywołać dowolny RemoteEvent albo dowolną RemoteFunction dowolnie wiele razy i z dowolnymi argumentami. Jedyne, czego nie może podrobić, to pierwszy parametr: Roblox sam wstawia Player, który wysłał wiadomość. Wszystko, co idzie dalej, trzeba sprawdzić, zanim serwer zacznie działać. Ukrywanie remote’a albo sprawdzanie w LocalScript nic nie daje, bo oszust kontroluje swojego klienta.

Lista kontrolna dla serwera
SprawdzeniePytanie, które zadaje serwerPrzykład
TypCzy to typ, którego oczekuję? Instance, a nie tabela zbudowana tak, żeby go przypominać?typeof(part) == "Instance" and part:IsA("BasePart")
ZakresCzy liczba jest skończona i mieści się w dozwolonych granicach? Czy tekst ma rozsądną długość?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
PrzynależnośćCzy ten gracz posiada przedmiot, czy ma dość pieniędzy, czy ma prawo działać na tym obiekcie?Przedmiot jest w jego ekwipunku; part leży w Paintable
OdległośćCzy postać gracza w serwerowej kopii świata jest dość blisko? Zostaw mały zapas na lagi.Nie dalej niż 30 studów od partu
CzęstotliwośćCzy ten gracz nie wysyła za często?Cooldown na gracza albo limit z kumulowaniem wywołań

NaN zasługuje na osobne ostrzeżenie. To liczba, więc type(x) == "number" przechodzi, ale każde porównanie z nią daje false, a sprawdzenie w rodzaju x < 0 or x > 100 przepuszcza ją na wylot. math.isfinite(x) odrzuca NaN i obie nieskończoności.

Pamiętaj o granicy sprawdzenia odległości. Każdy klient steruje fizyką swojej postaci, więc exploiter może przed wywołaniem przenieść postać do celu. Sprawdzenie i tak zatrzymuje najprostsze nadużycie, czyli działanie z jednego miejsca na całą mapę. Trzymaj party docelowe zakotwiczone: w dokumentacji Roblox o bezpieczeństwie zaznaczono, że exploiter może dostać własność sieciową niezakotwiczonych partów obok siebie i przyciągnąć je bliżej, a to omija sprawdzenie odległości.

Oto te same sprawdzenia jako ModuleScript, którego można używać w każdym handlerze remote’a.

ModuleScript w ServerScriptService o nazwie RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Prawdziwa liczba między min a max. Odrzuca NaN i nieskończoność, które przechodzą
-- zwykłe sprawdzenie 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

-- Liczba całkowita między min a max, dla ilości, indeksów i liczników
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 z ograniczeniem długości. utf8.len zwraca nil dla niepoprawnego UTF-8, który
-- magazyny danych odrzucają.
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

-- Instance oczekiwanej klasy w kontenerze, na który pozwoliłeś.
-- Tabela zbudowana tak, żeby przypominać Instance, nie przechodzi sprawdzenia typeof.
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, gdy postać gracza jest nie dalej niż maxDistance studów od 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

-- Limit częstotliwości na gracza. Każdy gracz może zrobić `burst` wywołań naraz i
-- dostaje z powrotem `perSecond` wywołań co sekundę. Zwraca funkcję, którą wywołuje się
-- przed pracą: odpowiada true (można) albo false (za często).
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

Trzymaj go w ServerScriptService. Kod stamtąd nigdy nie trafia do klientów, więc nikt nie przeczyta twoich sprawdzeń.

A oto handler ze schematu 1, przepisany z jego pomocą. Zastąp zawartość PaintServer:

Script w ServerScriptService o nazwie PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" ma znaczenie tylko dla ścisłego sprawdzania typów Luau; w trakcie działania niczego nie zmienia
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) -- paczka 4, potem 4 na 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)

Limiter usuwa wpis gracza, gdy ten wychodzi, więc jego tabela nie rośnie przez cały czas życia serwera.

W broni te sprawdzenia są najważniejsze: nigdy nie pozwalaj klientowi zgłaszać, w kogo trafił. Remote z poradnika o mieczu w ogóle nie niesie argumentów, a serwer sam znajduje cele. Poradnik o broni wysyła tylko punkt celowania, który serwer sprawdza pod kątem typu, NaN i odległości, zanim puści własny promień.

Menu podlegają tej samej zasadzie: wysyłaj wybór, a nie wynik. W poradniku o dialogach z NPC klient wysyła tylko numer klikniętego przycisku, a serwer sam sprawdza, co daje ta odpowiedź. Menu z poradnika o teleportach wysyła nazwę punktu, a nie pozycję, a serwer znajduje punkt w swoim folderze i sprawdza, ile Wins jest do niego potrzebne.

Co można, a czego nie można wysyłać

Można przekazywać liczby, stringi, wartości logiczne, typy Roblox, takie jak Vector3, CFrame, Color3 i elementy Enum, Instance, które widzą obie strony, i tabele z tego wszystkiego. Niektóre wartości po drodze się zmieniają albo znikają:

Argumenty, które przychodzą inne, niż zostały wysłane
WysyłaszCo się dzieje
FunkcjęDruga strona dostaje nil
Tabelę z metatabeląMetatabela ginie razem ze wszystkim, co tabela miała tylko przez nią
Tabelę, w której są wymieszane klucze liczbowe i tekstoweRoblox radzi tak nie robić: wysyłaj czystą tablicę albo czysty słownik
Tabelę z wartościami nil w środkuUnikaj: Roblox nie radzi nil pod żadnym indeksem
Tabelę z kluczami typu Instance, userdata albo functionTakie klucze zamieniają się w stringi
Instance, którego odbiorca nie widzi, na przykład z ServerStorage albo utworzony w LocalScriptDruga strona dostaje nil
Dowolną tabelęOdbiorca dostaje kopię, a nie tę samą tabelę

Dobry nawyk: wysyłać identyfikatory, a nie obiekty ani wartości. Nazwę przedmiotu, numer opcji, part, który serwer może znaleźć i sprawdzić. Dalej serwer pracuje na swoich danych.

Dlaczego RemoteFunction zwraca nil

Jeśli InvokeServer oddaje ci nil, przejdź po tych punktach po kolei:

  1. Ścieżka bez zwracanej wartości. Każde wyjście z OnServerInvoke musi coś zwracać. Pusty return we wczesnym sprawdzeniu odsyła z powrotem nil.
  2. return w zagnieżdżonej funkcji. return w pcall(function() ... end), handlerze :Connect albo task.spawn wychodzi tylko z tej wewnętrznej funkcji. Zapisz wynik, na przykład local ok, data = pcall(...), a potem zwróć data z samego callbacku.
  3. Wartość, która nie może przekroczyć granicy. Funkcja albo Instance, którego klient nie widzi (na przykład cokolwiek w ServerStorage), przychodzi jako nil. Przy włączonym instance streaming part, który serwer dopiero co utworzył, mógł jeszcze nie dotrzeć do klienta w chwili powrotu z funkcji.
  4. Callback ustawił inny skrypt. Działa tylko ostatnie przypisanie OnServerInvoke. Poszukaj nazwy remote’a w swoich skryptach.

Jeśli wywołanie w ogóle nie wraca, to żaden skrypt nie ustawił jeszcze OnServerInvoke (Roblox trzyma wywołania w kolejce, dopóki go nie ustawią) albo callback zawisł, na przykład na WaitForChild dla czegoś, co nigdy się nie pojawi.

UnreliableRemoteEvent: do ciągłych jednorazowych aktualizacji

UnreliableRemoteEvent ma te same metody i eventy co RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent i OnClientEvent. Różnica jest taka, że Roblox nie gwarantuje ani dostarczenia, ani kolejności. Wiadomość może zostać odrzucona bez ponownego wysłania, gdy:

  • gubi się po drodze albo za długo czeka w przeciążonej sieci
  • jej dane są większe niż 1000 bajtów
  • klient wysyła częściej niż limit (nadmiar jest odrzucany, a nie odkładany)
  • w chwili przyjścia nie jest podłączony żaden handler (jest wyrzucana, a nie ustawiana w kolejce)

Wiadomości mogą też przychodzić nie po kolei, a ich kolejność nie ma żadnego związku z twoimi RemoteEvent ani RemoteFunction. Używaj go, gdy liczy się tylko najświeższa wartość, a następna aktualizacja przyjdzie za ułamek sekundy: gdzie celuje gracz, pozycja efektu kosmetycznego, wartość, która zmienia się co klatkę. Jeśli kolejność jest ważna, wkładaj do każdej wiadomości numer porządkowy albo znacznik czasu i ignoruj wszystko, co starsze niż ostatnia obsłużona.

Nigdy nie używaj go do tego, co ma się wydarzyć dokładnie raz, na przykład do zakupu, obrażeń, nagrody albo startu rundy. I sprawdzaj jego argumenty na serwerze dokładnie tak samo jak w RemoteEvent.

Kolejność dostarczania i limity częstotliwości

Gwarancje dostarczania Roblox dotyczą jednego połączenia w jednym kierunku: od serwera do jednego klienta albo od jednego klienta do serwera.

  • RemoteEvent są niezawodne i uporządkowane. Zgubione wiadomości są wysyłane ponownie, dopóki odbiorca jest połączony, a wiadomości przychodzą w kolejności, w jakiej je wysłałeś, nawet przez różne RemoteEvent. Jeśli serwer wysyła graczowi A, potem B, potem A, ten gracz dostaje A, B, A.
  • Kolejność dotyczy chwili uruchomienia handlerów. Jeśli handler oddaje sterowanie, na przykład przez task.wait albo WaitForChild, następna wiadomość może zacząć być obsługiwana, zanim skończy się pierwsza.
  • RemoteFunction i RemoteEvent nie są uporządkowane względem siebie. Jeśli twój kod zależy od ścisłej kolejności, wysyłaj powiązane wiadomości przez jeden typ remote’a albo dodaj własny numer porządkowy.
  • Zmiany właściwości i atrybutów nie są uporządkowane względem remote’ów. Jeśli serwer zmienia właściwość, a potem wywołuje remote, klient może zobaczyć jako pierwsze którekolwiek z nich. Nasłuchuj samej zmiany, na przykład przez GetPropertyChangedSignal, zamiast zakładać, że już przyszła.
  • Handlera jeszcze nie ma. Wiadomości RemoteEvent czekają w kolejce, dopóki handler się nie podłączy. Kolejka ma granice: gdy jest pełna, następne wiadomości są odrzucane, a w Output pojawia się błąd Remote event invocation discarded.
  • Gracz, który wychodzi, traci wszystkie wiadomości, które jeszcze do niego nie dotarły.

Limit częstotliwości. Wiadomości RemoteEvent i UnreliableRemoteEvent od klienta do serwera są ograniczone do około 500 zapytań na sekundę na klienta, według dokumentacji z 30 września 2026. Limit jest wspólny dla wszystkich remote’ów jednego typu, więc podzielenie jednego zajętego remote’a na dziesięć go nie podnosi. Ponad limit wiadomości RemoteEvent są obsługiwane później i zachowują kolejność, a wiadomości UnreliableRemoteEvent są odrzucane. Limit silnika w żaden sposób nie przeszkadza jednemu graczowi wywoływać twojego remote’a 50 razy na sekundę, więc każdy handler, który coś zmienia, i tak potrzebuje własnego limitu na gracza.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent czy atrybut?

Jak wybrać sposób komunikacji klienta i serwera
UżywajDo czegoPrzykładNa co uważać
RemoteEventWiadomości w jedną stronę, które muszą dotrzeć, i to po koleiKlient: „pomaluj ten part”. Serwer: „pokaż to powiadomienie”Sprawdzaj każdy argument na serwerze
RemoteFunction z InvokeServerKlient potrzebuje odpowiedzi, zanim będzie mógł iść dalejWpisanie kodu promocyjnego, potwierdzenie zakupuWywołujący czeka; każda ścieżka musi zwracać wartość
RemoteFunction z InvokeClientPrawie nigdyUżywaj zamiast tego FireClientKlient, który ma błąd, wyszedł albo nie odpowiedział, psuje albo zawiesza wywołanie na serwerze
UnreliableRemoteEventCzęste aktualizacje, gdzie liczy się tylko ostatniaKierunek celowania, efekty kosmetyczneWiadomości gubią się albo zmieniają kolejność; limit danych 1000 bajtów
Atrybut albo obiekt wartości ustawiony przez serwerWspólny stan, który ma być zawsze widoczny, także dla graczy, którzy weszli późniejTimer rundy, faza gry, czy drzwi są otwarteDo wszystkich docierają tylko zmiany serwera; klienci nasłuchują przez GetAttributeChangedSignal albo Changed
BindableEventKomunikacja skryptów po jednej stronieJeden serwerowy skrypt informuje drugi, że runda się skończyłaNie przechodzi między serwerem a klientem

Pełny przykład tego, jak RemoteFunction i sprawdzenia działają razem tam, gdzie gracze płacą, zobacz w poradniku jak zrobić GUI sklepu. Co do wiersza o atrybutach, serwerowy skrypt z poradnika o drzwiach ustawia atrybut Open na każdych drzwiach przy każdym ich ruchu, więc może na niego reagować dowolny LocalScript.

Częste błędy i rozwiązania

Większość problemów z remote’ami widać w oknie Output (otwórz je z menu Window albo z karty Script). Najpierw zajrzyj tam, potem znajdź swój objaw niżej. Poradnik o błędach skryptów szerzej omawia ogólne komunikaty o błędach.

Infinite yield possible przy WaitForChild dla remote’a

Skrypt czeka na remote, który nigdy się nie pojawi. Sprawdź, czy nazwa i wielkość liter zgadzają się dokładnie i czy remote leży w ReplicatedStorage, a nie w ServerStorage albo ServerScriptService, których klienci nie widzą.

Serwer dostaje nie te wartości, przesunięte o jedną

LocalScript przekazał samego gracza, jak w remote:FireServer(player, 5). Roblox i tak dodaje nadawcę jako pierwszy parametr, więc serwer widzi (player, player, 5). Wywołuj remote:FireServer(5).

Nic się nie dzieje, gdy wywołuję remote

Sprawdź, czy każde wywołanie idzie z właściwej strony: FireServer i InvokeServer działają tylko z kodu klienckiego, a FireClient, FireAllClients i InvokeClient tylko z serwerowego Script. LocalScript nigdy nie uruchamia się w ServerScriptService, ServerStorage ani bezpośrednio w Workspace; wkładaj go do StarterPlayerScripts, StarterGui, StarterCharacterScripts albo StarterPack. Potem poszukaj w Output błędu w handlerze.

Remote event invocation discarded

Wiadomości przyszły do RemoteEvent, który nie miał podłączonego handlera, i kolejka się zapełniła. Zwykle skrypt z handlerem wywala się z błędem przed linią z :Connect, jest wyłączony albo zawisł w oczekiwaniu na coś, co nigdy się nie wczyta. Podłączaj handlery bliżej początku skryptu.

U mnie działa, ale inni gracze nie widzą zmiany

Zmiana jest zrobiona na kliencie, w LocalScript albo w handlerze OnClientEvent. Rób ją w serwerowym handlerze OnServerEvent.

InvokeServer nigdy nie wraca

Albo żaden skrypt nie ustawił OnServerInvoke (Roblox trzyma wywołania w kolejce, dopóki go nie ustawią), albo callback zawisł na czymś, co oddaje sterowanie, na przykład na WaitForChild albo zapytaniu do magazynu danych. Dodaj print na początku i na końcu callbacku, żeby zobaczyć, gdzie się zatrzymuje.

Zrób to z RoCode

To może ustawić też RoCode, prosto w grze, którą masz otwartą. RoCode to agent AI, który działa przez plugin do Roblox Studio, więc tworzy remote’y i skrypty w twoim Explorerze, a nie daje kodu, który trzeba wklejać.

Ty piszesz

Niech gracze malują party w folderze Paintable kliknięciem. Użyj RemoteEvent i zostaw sprawdzenia na serwerze: tylko party z tego folderu, nie dalej niż 30 studów i nie więcej niż kilka malowań na sekundę.

RoCode robi
  • Zwykle najpierw przegląda grę przez Search Game i Search Scripts w poszukiwaniu gotowego folderu Remotes albo handlera i używa twoich folderów, jeśli są
  • Tworzy RemoteEvent w ReplicatedStorage przez Create Instance i pisze serwerowy Script i LocalScript przez Create Script
  • Przed zakończeniem sprawdza kompilację każdego skryptu przez Check Script w Studio. To wyłapuje błędy kompilacji, a nie błędy logiki: nie sprawdza typów, nie uruchamia lintera i nie wykonuje twojego kodu
  • Wysyła zmiany paczkami, a każda paczka to punkt cofania w historii Studio

Z pluginem 3.9 lub nowszym RoCode może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.11 lub nowszym może sterować testową postacią, ale nie klika partów w oknie 3D. Kliknij Play sam i spróbuj zepsuć sprawdzenia, na przykład malując part z drugiego końca mapy. Jeśli pojawił się błąd, Check Output może przeczytać linie Server i Client z twojego ostatniego playtestu. Większość systemów gry komunikuje się przez takie remote’y, więc spotkasz je znowu, gdy będziesz budować grę system po systemie z RoCode. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Co znaczy securing the client-server boundary w Roblox?

Tak nazywa się strona dokumentacji Roblox o bezpieczeństwie remote’ów, a idea jest prosta: wszystko, co klient wysyła przez RemoteEvent albo RemoteFunction, może pochodzić od exploitera, więc serwer to sprawdza, zanim zadziała. Sprawdzaj typ każdego argumentu, trzymaj liczby w rozsądnych granicach, sprawdzaj, czy gracz może to teraz robić, i ograniczaj, jak często każdy gracz może wywoływać remote. Lista sprawdzeń wyżej pokazuje każde z nich w kodzie.

Czy używanie RemoteFunction jest bezpieczne?

InvokeServer jest tak bezpieczne, jak bezpieczny jest twój serwerowy callback: sprawdzaj jego argumenty i ograniczaj częstotliwość jak w każdym RemoteEvent. Ryzykowny kierunek to InvokeClient, bo klient, który ma błąd, wyszedł albo nigdy nie zwrócił wartości, psuje albo zawiesza wywołanie na serwerze.

Czy exploiterzy widzą i mogą wywoływać moje remote’y?

Tak. Wszystko, co leży w ReplicatedStorage, dociera do każdego klienta, a zmodyfikowany klient może wywołać dowolny remote z dowolnymi argumentami. Zmiana nazwy albo ukrycie remote’ów nie czyni ich bezpiecznymi; bezpiecznymi czyni je sprawdzanie każdego argumentu na serwerze.

Czy jeden klient może wysłać RemoteEvent innemu klientowi?

Bezpośrednio nie. Wyślij go na serwer, sprawdź tam, potem użyj FireClient albo FireAllClients.

Jak często można wywoływać RemoteEvent?

W dokumentacji Roblox podano limit około 500 zapytań na sekundę na klienta dla wiadomości RemoteEvent i UnreliableRemoteEvent wysyłanych do serwera, wspólny dla wszystkich remote’ów jednego typu. Trzymaj się dużo poniżej niego i daj każdemu handlerowi własny limit na gracza.

Czy FireAllClients dociera do graczy, którzy weszli później?

Nie. Dociera do graczy podłączonych w tej chwili. Dla stanu, którego potrzebują spóźnialscy, ustaw na serwerze atrybut albo obiekt wartości.

Czym różni się RemoteEvent od BindableEvent?

RemoteEvent przechodzi między serwerem a klientem. BindableEvent łączy skrypty po jednej stronie, na przykład dwa serwerowe skrypty.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.