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 (
InvokeServeriOnServerInvoke) tylko wtedy, gdy klient potrzebuje odpowiedzi. UnikajInvokeClient: 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
Po co są RemoteEvent
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.
| Kierunek | Nadawca wywołuje | Odbiorca podłącza się do | Odbiorca dostaje |
|---|---|---|---|
| Od klienta do serwera | remote:FireServer(...) w LocalScript | remote.OnServerEvent w Script | Player, który wysłał wiadomość, potem twoje argumenty |
| Od serwera do jednego klienta | remote:FireClient(player, ...) w Script | remote.OnClientEvent w LocalScript | Tylko twoje argumenty |
| Od serwera do wszystkich klientów | remote:FireAllClients(...) w Script | remote.OnClientEvent w LocalScript | Tylko twoje argumenty |
| Klient pyta, serwer odpowiada | remoteFunction: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ść.
- W Explorerze najedź kursorem na ReplicatedStorage, kliknij przycisk + i wstaw Folder. Nazwij folder
Remotes. - Najedź kursorem na
Remotes, kliknij + i wstaw RemoteEvent. Zmień jego nazwę tak, żeby opisywała przeznaczenie, na przykładPaintRequest. - Powtórz dla każdego remote’a. W tym poradniku używamy dwóch RemoteEvent (
PaintRequestiNotify) i jednej RemoteFunction (RedeemCode).
ReplicatedStorage
Remotes Folder new
PaintRequest RemoteEvent new
Notify RemoteEvent new
RedeemCode RemoteFunction new
ServerScriptService
PaintServer Script new
WelcomeServer Script new
FinishAnnouncer Script new
RedeemServer Script new
RemoteGuard ModuleScript new
StarterPlayer
StarterPlayerScripts
PaintClient LocalScript new
NotifyClient LocalScript new
StarterGui
CodeGui ScreenGui new
CodeBox TextBox new
RedeemClient LocalScript new
Workspace
Paintable Folder new
FinishLine Part new
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ć.
- W Workspace wstaw Folder o nazwie
Paintablei włóż do niego kilka zakotwiczonych Partów. - Sprawdź, czy w
ReplicatedStorage.Remotesjest RemoteEvent o nazwiePaintRequest. - Wstaw Script o nazwie
PaintServerdo ServerScriptService i LocalScript o nazwiePaintClientdo StarterPlayer, StarterPlayerScripts, z kodem poniżej.
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ę.
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.
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
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.
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.
- W
ReplicatedStorage.Remoteswstaw RemoteFunction o nazwieRedeemCode. - W StarterGui wstaw ScreenGui o nazwie
CodeGui, a do niego TextBox o nazwieCodeBox. Rozmiar i miejsce wybierz według uznania. - Dodaj Script poniżej do ServerScriptService, a LocalScript do
CodeBox.
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.
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,
InvokeClientrzuci 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.
| Sprawdzenie | Pytanie, które zadaje serwer | Przykład |
|---|---|---|
| Typ | Czy to typ, którego oczekuję? Instance, a nie tabela zbudowana tak, żeby go przypominać? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Zakres | Czy 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.
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:
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ą:
| Wysyłasz | Co 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 tekstowe | Roblox radzi tak nie robić: wysyłaj czystą tablicę albo czysty słownik |
Tabelę z wartościami nil w środku | Unikaj: Roblox nie radzi nil pod żadnym indeksem |
| Tabelę z kluczami typu Instance, userdata albo function | Takie klucze zamieniają się w stringi |
| Instance, którego odbiorca nie widzi, na przykład z ServerStorage albo utworzony w LocalScript | Druga 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:
- Ścieżka bez zwracanej wartości. Każde wyjście z
OnServerInvokemusi coś zwracać. Pustyreturnwe wczesnym sprawdzeniu odsyła z powrotemnil. - return w zagnieżdżonej funkcji.
returnwpcall(function() ... end), handlerze:Connectalbotask.spawnwychodzi tylko z tej wewnętrznej funkcji. Zapisz wynik, na przykładlocal ok, data = pcall(...), a potem zwróćdataz samego callbacku. - 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. - 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.waitalboWaitForChild, 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?
| Używaj | Do czego | Przykład | Na co uważać |
|---|---|---|---|
| RemoteEvent | Wiadomości w jedną stronę, które muszą dotrzeć, i to po kolei | Klient: „pomaluj ten part”. Serwer: „pokaż to powiadomienie” | Sprawdzaj każdy argument na serwerze |
RemoteFunction z InvokeServer | Klient potrzebuje odpowiedzi, zanim będzie mógł iść dalej | Wpisanie kodu promocyjnego, potwierdzenie zakupu | Wywołujący czeka; każda ścieżka musi zwracać wartość |
RemoteFunction z InvokeClient | Prawie nigdy | Używaj zamiast tego FireClient | Klient, który ma błąd, wyszedł albo nie odpowiedział, psuje albo zawiesza wywołanie na serwerze |
| UnreliableRemoteEvent | Częste aktualizacje, gdzie liczy się tylko ostatnia | Kierunek celowania, efekty kosmetyczne | Wiadomości gubią się albo zmieniają kolejność; limit danych 1000 bajtów |
| Atrybut albo obiekt wartości ustawiony przez serwer | Wspólny stan, który ma być zawsze widoczny, także dla graczy, którzy weszli później | Timer rundy, faza gry, czy drzwi są otwarte | Do wszystkich docierają tylko zmiany serwera; klienci nasłuchują przez GetAttributeChangedSignal albo Changed |
| BindableEvent | Komunikacja skryptów po jednej stronie | Jeden serwerowy skrypt informuje drugi, że runda się skończyła | Nie 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ć.
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ę.
- 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
- Roblox Creator Docs: Remote events and callbacks (po angielsku). FireServer, FireClient, InvokeServer, ryzyka InvokeClient, ograniczenia argumentów i gwarancje dostarczania
- Roblox Creator Docs: Securing the client-server boundary (po angielsku). Poziomy sprawdzania, NaN, limity częstotliwości, przekazywanie od klienta do klienta
- Roblox Creator Docs: Security and cheat mitigation tactics (po angielsku). Co może zmodyfikowany klient i autorytet serwera
- Roblox Creator Docs: Network ownership, movement validation, and physics (po angielsku). Dlaczego klient steruje swoją postacią i granice sprawdzeń odległości
- Roblox Engine API: RemoteEvent (po angielsku). Limit częstotliwości i błąd invocation discarded
- Roblox Engine API: RemoteFunction (po angielsku). OnServerInvoke, ostrzeżenia o InvokeClient i środki ostrożności ze streamingiem
- Roblox Engine API: UnreliableRemoteEvent (po angielsku). Limit danych 1000 bajtów
- Roblox Creator Docs: Properties and attributes (po angielsku). Kolejność replikacji między zmianami właściwości a remote events
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ą.