Ve zkratce
RemoteEvent je objekt, který obvykle leží v ReplicatedStorage a předává zprávy přes hranici mezi klientem a serverem. LocalScript zavolá FireServer a server zprávu dostane v OnServerEvent, kde je jako první argument přidaný Player, který ji poslal. Server zavolá FireClient(player, ...) nebo FireAllClients(...) a LocalScripty zprávu dostanou v OnClientEvent.
- Používejte RemoteFunction (
InvokeServeraOnServerInvoke), jen když klient potřebuje odpověď. Vyhněte seInvokeClient: klient, u kterého došlo k chybě, který odešel nebo nikdy nevrátil hodnotu, rozbije volání na serveru. - Nikdy nevěřte tomu, co klient posílá. Na serveru kontrolujte typ, rozsah a vlastnictví každého argumentu, vzdálenost hráče a to, jak často remote volá.
- Funkce, metatabulky a objekty, které druhá strana nevidí, přenos nepřežijí. UnreliableRemoteEvent může zprávy ztrácet nebo měnit jejich pořadí a zahodí jakákoli data větší než 1000 bajtů.
Na této stránce
K čemu jsou RemoteEventy
Každá hra v Robloxu funguje jako jeden server plus jeden klient na každého hráče. Server je tu hlavní: nový objekt nebo změna vlastnosti se dostane ke všem hráčům, jen když ji udělá server. Změna provedená v LocalScriptu zůstane na jednom zařízení, s několika výjimkami, jako je vlastní postava hráče, jejíž pohyb řídí jeho klient. Proto když má kliknutí nebo stisk klávesy změnit společný svět, klient musí server požádat, a když server chce, aby zareagovala obrazovka jednoho hráče, musí to klientovi oznámit. Pokud je pro vás rozdělení na Script a LocalScript nové, přečtěte si nejdřív Script vs LocalScript vs ModuleScript (anglicky). Pokud je nové samotné skriptování, začněte tím, jak psát skripty v Roblox Studiu.
K překročení této hranice dává Roblox tři objekty:
- RemoteEvent: zpráva jedním směrem. Odesílatel hned pokračuje v práci.
- RemoteFunction: požadavek, který čeká na odpověď. Volající kód stojí, dokud druhá strana nevrátí hodnotu.
- UnreliableRemoteEvent: zpráva jedním směrem, která se může ztratit nebo přijít mimo pořadí, ale méně zatěžuje síť. Hodí se pro data, která se neustále mění.
| Směr | Odesílatel volá | Příjemce se připojí k | Příjemce dostane |
|---|---|---|---|
| Od klienta k serveru | remote:FireServer(...) v LocalScriptu | remote.OnServerEvent ve Scriptu | Player, který zprávu poslal, pak vaše argumenty |
| Od serveru jednomu klientovi | remote:FireClient(player, ...) ve Scriptu | remote.OnClientEvent v LocalScriptu | Jen vaše argumenty |
| Od serveru všem klientům | remote:FireAllClients(...) ve Scriptu | remote.OnClientEvent v LocalScriptu | Jen vaše argumenty |
| Klient se ptá, server odpovídá | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player, pak vaše argumenty. Volající dostane to, co funkce vrátila |
Klienti si nemohou posílat zprávy přímo. Chcete-li něco předat od jednoho hráče ostatním, pošlete to na server, tam to zkontrolujte a ať to server pošle dál přes FireClient nebo FireAllClients. Podle bezpečnostních doporučení Robloxu tu server funguje jako vrátný, ne jako pouhý přeposílač.
Kde remoty uchovávat
Remote musí ležet tam, kde ho vidí server i klienti. Obvyklé místo je ReplicatedStorage; dokumentace Robloxu uvádí, že v některých případech poslouží i Workspace nebo Tool. ServerStorage a ServerScriptService jsou dostupné jen serveru, takže LocalScript, který na remote odtamtud čeká, bude čekat věčně.
- V Exploreru najeďte myší na ReplicatedStorage, klikněte na tlačítko + a vložte Folder. Pojmenujte složku
Remotes. - Najeďte myší na
Remotes, klikněte na + a vložte RemoteEvent. Přejmenujte ho tak, aby název popisoval účel, napříkladPaintRequest. - Zopakujte pro každý remote. Tento návod používá dva RemoteEventy (
PaintRequestaNotify) a jednu 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
Skripty v tomto návodu hledají remoty přes WaitForChild. Ten vrátí výsledek hned, pokud remote už existuje, a čeká, pokud ještě ne, například když serverový skript vytváří remoty během hry. Pro každý druh požadavku mějte vlastní remote: pak každý handler na serveru kontroluje jednu podobu argumentů a udělat to správně je mnohem jednodušší než s jedním remotem pro všechno.
Vzor 1: od klienta k serveru, s kontrolou na serveru
Nejčastější úkol: hráč něco udělá na své obrazovce a server rozhodne, co se stane. Tady hráč stiskne Q, vybere jednu ze čtyř barev, a klikne nebo klepne na part, aby ho obarvil. Novou barvu vidí všichni, protože barví server.
Klient posílá dvě věci: který part a číslo barvy. Samotnou barvu nikdy neposílá a v jiných hrách stejně tak nemá posílat cenu, odměnu ani velikost poškození. Upravený klient může poslat cokoli, proto skutečná data (tady paletu) drží server a argumenty bere jako požadavek, který je třeba ověřit.
- Do Workspace vložte Folder s názvem
Paintablea dejte do ní několik ukotvených Partů. - Ověřte, že v
ReplicatedStorage.Remotesje RemoteEvent s názvemPaintRequest. - Vložte Script s názvem
PaintServerdo ServerScriptService a LocalScript s názvemPaintClientdo StarterPlayer, StarterPlayerScripts, s kódem níže.
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")
-- Barvy patří serveru. Klient posílá jen číslo, které jednu z nich vybere.
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ů mezi postavou a partem
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- První parametr je vždy hráč, který remote zavolal. Doplňuje ho Roblox,
-- takže mu lze věřit. Všechno za ním přišlo od klienta a tomu věřit nelze.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Typ: skutečný part, ne tabulka, která se za něj vydává
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Rozsah: celé číslo od 1 do 4. NaN a nekonečno se odfiltrují také tady.
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. Povolený cíl: jen party ve složce Paintable, nic jiného ve hře
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Vzdálenost: postava hráče musí být u 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 četnosti: jedno obarvení na hráče jednou za čtvrt 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ždá neprošlá kontrola prostě udělá return. Vysvětlovat podvádějícímu klientovi, proč byl odmítnut, není důvod.
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 -- skutečné barvy uchovává server
local selectedColour = 1
-- Paprsek může trefit jen party uvnitř složky 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 -- klávesa nebo kliknutí šly do chatu nebo na tlačítko
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
-- Žádáme, nepřikazujeme: jestli obarvit, rozhoduje server
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed je true, když engine tento vstup už zpracoval, obvykle v rozhraní: kliknutí na tlačítko nebo klávesy napsané do textového pole, jako je řádek chatu. Díky této kontrole písmeno Q napsané ve zprávě nezmění barvu.
Vzor 2: od serveru jednomu klientovi
Server pošle zprávu jednomu hráči přes FireClient. Prvním argumentem je Player, kterému je určená, a handler na klientu dostane jen argumenty za ním. Používejte to pro všechno osobní: oznámení, okno s odměnou, zvuk, který má slyšet jen tento hráč. Návod k cutscénám je větší rozebraný příklad: server rozhodne, kdy hráč cutscénu uvidí, a pošle její záběry tomuto jednomu hráči přes FireClient, a kamerou hýbe jeho zařízení.
Tato dvojice skriptů ukáže pozdrav, když hráč přijde. LocalScript si malý banner postaví sám, takže GUI nastavovat nemusíte.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local function welcome(player: Player)
-- První argument vybírá, který klient zprávu dostane. Nikdo jiný ji neuvidí.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- Ve Studiu můžete přijít dřív, než se tento skript připojí, proto pozdravíme všechny, kdo už tu jsou
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
-- Malý banner nahoře na obrazovce postavený v kódu
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
-- Tady není parametr player: server už vybral, kdo zprávu dostane
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 -- skryjeme, pokud ho nenahradila novější zpráva
label.Visible = false
end
end)
end)
Server posílá zprávu při PlayerAdded, a to se může stát dřív, než tento LocalScript připojí svůj handler. To nevadí: Roblox zprávy RemoteEventu, které přišly před objevením handleru, zařadí do fronty a doručí je popořadě, jakmile se handler připojí.
Klient se nemusí chránit před serverem: vyvolat OnClientEvent může jen serverový kód. Anotace message: string je pro kontrolu typů; není to kontrola za běhu.
Vzor 3: od serveru všem klientům
FireAllClients pošle stejnou zprávu každému připojenému hráči. Nemá argument Player a každý klient zprávu dostane ve stejném OnClientEvent jako předtím, takže skript NotifyClient ze vzoru 2 ji už zobrazí.
Tento Script všem oznámí, když se hráč poprvé dotkne cílové čáry. Přidejte do Workspace ukotvený Part s názvem FinishLine a pak přidejte 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 -- není to hráč, nebo už byl oznámen
end
finished[player] = true
-- Každý připojený klient spustí svůj handler OnClientEvent s tímto textem
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
Exploiter může vyvolat Touched pro svou postavu z jakékoli vzdálenosti, ale u oznámení, které se ukáže jednou na hráče, je to neškodné. Pokud později budete za cíl dávat odměnu, přidejte před vydáním kontroly na serveru, například minimální čas od začátku kola.
FireAllClients dorazí jen k hráčům připojeným v tu chvíli. Kdo přijde o sekundu později, zprávu už neuvidí. To se hodí pro jednorázové okamžiky, jako je oznámení, efekt výbuchu nebo zvuk, ale ne pro stav, jako je časovač kola nebo současná fáze hry. Pro stav nastavte na serveru atribut, například ReplicatedStorage:SetAttribute("TimeLeft", 30), a na klientu ho čtěte přes GetAttribute a GetAttributeChangedSignal("TimeLeft"). Atributy se replikují každému klientovi, včetně hráčů, kteří přišli později.
RemoteFunction: když klient potřebuje odpověď
RemoteEvent funguje na principu „pošli a zapomeň“. RemoteFunction nechá volajícího čekat: InvokeServer pozastaví kód, který ho zavolal, dokud serverová funkce OnServerInvoke nevrátí hodnotu, a pak vydá to, co vrátila. Používejte ji, když klient bez odpovědi nemůže pokračovat, například „byl tento kód správný?“. Když odpověď potřeba není, Roblox doporučuje RemoteEvent, protože nečeká.
Příklad: pole, kam hráči zadávají promo kód. Server uchovává kódy, zkontroluje text a vrátí dvě hodnoty: jestli to fungovalo a zprávu, kterou má ukázat.
- Do
ReplicatedStorage.Remotesvložte RemoteFunction s názvemRedeemCode. - Do StarterGui vložte ScreenGui s názvem
CodeGuia do něj TextBox s názvemCodeBox. Velikost a místo vyberte podle sebe. - Přidejte Script níže do ServerScriptService a LocalScript dovnitř
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Kódy žijí na serveru, kde je žádný hráč nemůže přečíst
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 } = {}
-- Přiřazujeme přes =. OnServerInvoke je callback, ne událost, ke které se dělá 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)
Přičítá ke statistice Coins z návodu k leaderboardu. Použité kódy se pamatují jen do odchodu hráče, takže v této podobě se hráč může znovu připojit a zadat stejný kód znovu. Pokud se mince ukládají, jsou to mince zdarma při každém novém připojení: než to použijete v živé hře, ukládejte použité kódy každého hráče spolu s jeho uloženými daty v úložišti dat.
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 tuto funkci pozastaví, dokud callback serveru nevrátí hodnotu.
-- pcall zabrání zastavení LocalScriptu, pokud volání selže.
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 má přesně jeden serverový callback. Pokud dva skripty nastaví OnServerInvoke u stejné RemoteFunction, funguje jen ten poslední.
V čem je InvokeClient nebezpečný
RemoteFunction funguje i opačným směrem, s InvokeClient na serveru a OnClientInvoke na klientu. Dokumentace Robloxu uvádí tři vážná rizika:
- Pokud callback klienta hodí chybu, server také hodí chybu.
- Pokud hráč během volání odejde,
InvokeClienthodí chybu. - Pokud klient nikdy nevrátí hodnotu, serverový skript bude čekat věčně.
Upravený klient ovládá svůj callback, takže podvodník může třetí případ vyvolat záměrně a držet toto serverové vlákno, jak dlouho chce. K aktualizaci obrazovky hráče používejte FireClient. Pokud server opravdu potřebuje informaci od klienta, pošlete RemoteEvent, ať klient odpoví přes jiný RemoteEvent, a chybějící odpověď berte na serveru jako běžný případ.
Kontrolujte každý argument na serveru
Exploiter může zavolat jakýkoli RemoteEvent nebo RemoteFunction kolikrát chce a s jakýmikoli argumenty. Jediné, co podvrhnout nemůže, je první parametr: Roblox sám doplní Player, který zprávu poslal. Všechno, co následuje, je potřeba zkontrolovat dřív, než server začne jednat. Schovávat remote nebo kontrolovat v LocalScriptu je zbytečné, protože podvodník svého klienta ovládá.
| Kontrola | Otázka, kterou si server klade | Příklad |
|---|---|---|
| Typ | Je to typ, který čekám? Instance, ne tabulka postavená tak, aby ji připomínala? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Rozsah | Je číslo konečné a v přípustných mezích? Má text rozumnou délku? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Vlastnictví | Vlastní tento hráč předmět, má dost peněz, má právo s tímto objektem jednat? | Předmět je v jeho inventáři; part leží uvnitř Paintable |
| Vzdálenost | Je postava hráče v serverové kopii světa dost blízko? Nechte malou rezervu na lagy. | Nejvýš 30 studů od partu |
| Četnost | Neposílá tento hráč příliš často? | Cooldown na hráče nebo limit s hromaděním volání |
NaN si zaslouží zvláštní varování. Je to číslo, takže type(x) == "number" projde, ale každé porovnání s ním dá false a kontrola jako x < 0 or x > 100 ho pustí skrz. math.isfinite(x) odmítne NaN i obě nekonečna.
Pamatujte na mez kontroly vzdálenosti. Každý klient ovládá fyziku své postavy, takže exploiter může postavu před voláním přesunout k cíli. Kontrola stejně zastaví nejjednodušší zneužití, kdy se z jednoho místa působí na celou mapu. Cílové party držte ukotvené: dokumentace Robloxu k bezpečnosti uvádí, že exploiter může získat síťové vlastnictví neukotvených partů poblíž a přitáhnout si je blíž, a tím kontrolu vzdálenosti obejde.
Tady jsou stejné kontroly jako ModuleScript, který můžete použít v každém handleru remotu.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Skutečné číslo mezi min a max. Odmítne NaN a nekonečno, které projdou
-- běžnou kontrolou 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
-- Celé číslo mezi min a max, pro počty, indexy a počítadla
function RemoteGuard.integer(value: unknown, min: number, max: number): number?
local n = RemoteGuard.number(value, min, max)
if n and n % 1 == 0 then
return n
end
return nil
end
-- Text s omezenou délkou. utf8.len vrací nil pro neplatné UTF-8, které
-- úložiště dat odmítají.
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 očekávané třídy uvnitř kontejneru, který jste povolili.
-- Tabulka postavená tak, aby připomínala Instance, kontrolou typeof neprojde.
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, když je postava hráče nejvýš maxDistance studů 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 četnosti na hráče. Každý hráč může udělat `burst` volání najednou a
-- každou sekundu dostane zpět `perSecond` volání. Vrátí funkci, kterou zavoláte
-- před prací: odpoví true (lze) nebo false (příliš často).
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
Držte ho v ServerScriptService. Kód odtud se nikdy nedostane na klienty, takže vaše kontroly nikdo nepřečte.
A tady je handler ze vzoru 1 přepsaný s jeho pomocí. Nahraďte obsah PaintServer:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" je důležité jen pro přísnou kontrolu typů Luau; za běhu nic nemění
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) -- dávka 4, pak 4 za sekundu
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 smaže záznam hráče, když hráč odejde, takže jeho tabulka neroste po celou dobu běhu serveru.
U zbraní jsou tyto kontroly nejdůležitější: nikdy nedovolte klientovi hlásit, koho zasáhl. Remote z návodu k meči nenese vůbec žádné argumenty a server cíle najde sám. Návod ke zbraním posílá jen bod míření, který server zkontroluje na typ, NaN a vzdálenost, než vystřelí vlastní paprsek.
Pro menu platí stejné pravidlo: posílejte volbu, ne výsledek. V návodu k dialogům s NPC klient posílá jen číslo stisknutého tlačítka a server se sám podívá, co tato odpověď dává. Menu z návodu k teleportům posílá název bodu, ne pozici, a server bod najde ve své složce a zkontroluje, kolik Wins je pro něj potřeba.
Co se dá a co nedá posílat
Předávat můžete čísla, řetězce, booleovské hodnoty, typy Robloxu jako Vector3, CFrame, Color3 a prvky Enum, Instance, které vidí obě strany, a tabulky z toho všeho. Některé hodnoty se cestou změní nebo ztratí:
| Posíláte | Co se stane |
|---|---|
| Funkci | Druhá strana dostane nil |
| Tabulku s metatabulkou | Metatabulka se ztratí spolu se vším, co tabulka měla jen přes ni |
| Tabulku se smíchanými číselnými a textovými klíči | Roblox to nedoporučuje: posílejte čisté pole nebo čistý slovník |
Tabulku s hodnotami nil uvnitř | Vyhněte se: Roblox nedoporučuje nil na žádném indexu |
| Tabulku s klíči typu Instance, userdata nebo function | Takové klíče se změní na řetězce |
| Instance, kterou příjemce nevidí, například ze ServerStorage nebo vytvořenou v LocalScriptu | Druhá strana dostane nil |
| Jakoukoli tabulku | Příjemce dostane kopii, ne tutéž tabulku |
Dobrý zvyk: posílejte identifikátory, ne objekty ani hodnoty. Název předmětu, číslo možnosti, part, který server může najít a ověřit. Dál server pracuje se svými daty.
Proč RemoteFunction vrací nil
Pokud vám InvokeServer vrací nil, projděte tyto body popořadě:
- Cesta bez návratové hodnoty. Každý výstup z
OnServerInvokemusí něco vracet. Prázdnýreturnv rané kontrole pošle zpětnil. - return uvnitř vnořené funkce.
returnuvnitřpcall(function() ... end), handleru:Connectnebotask.spawnvystoupí jen z této vnitřní funkce. Uložte výsledek, napříkladlocal ok, data = pcall(...), a pak vraťtedataze samotného callbacku. - Hodnota, která nemůže překročit hranici. Funkce nebo Instance, kterou klient nevidí (například cokoli ve ServerStorage), přijde jako
nil. Se zapnutým instance streaming se part, který server právě vytvořil, nemusel ke klientovi dostat do chvíle, kdy se funkce vrátí. - Callback nastavil jiný skript. Funguje jen poslední přiřazení
OnServerInvoke. Vyhledejte název remotu ve svých skriptech.
Pokud se volání nevrátí vůbec, žádný skript ještě nenastavil OnServerInvoke (Roblox drží volání ve frontě, dokud ho nikdo nenastaví), nebo callback uvízl, například na WaitForChild pro něco, co se nikdy neobjeví.
UnreliableRemoteEvent: pro neustálé jednorázové aktualizace
UnreliableRemoteEvent má stejné metody a události jako RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent a OnClientEvent. Rozdíl je v tom, že Roblox nezaručuje doručení ani pořadí. Zpráva se může zahodit bez opakovaného odeslání, když:
- se ztratí cestou nebo příliš dlouho čeká v přetížené síti
- má data větší než 1000 bajtů
- klient posílá častěji, než je limit (co je navíc, se zahodí, ne odloží)
- v okamžiku příchodu není připojený žádný handler (zahodí se, nezařadí se do fronty)
Zprávy mohou přicházet i mimo pořadí a jejich pořadí nijak nesouvisí s vašimi RemoteEventy nebo RemoteFunction. Použijte ho, když je důležitá jen nejčerstvější hodnota a další aktualizace přijde za zlomek sekundy: kam hráč míří, pozice kosmetického efektu, hodnota, která se mění každý snímek. Pokud na pořadí záleží, dejte do každé zprávy pořadové číslo nebo časovou značku a ignorujte všechno starší než poslední zpracovanou.
Nikdy ho nepoužívejte pro něco, co se má stát přesně jednou, například pro nákup, poškození, odměnu nebo začátek kola. A jeho argumenty kontrolujte na serveru úplně stejně jako u RemoteEventu.
Pořadí doručení a limity četnosti
Záruky doručení Robloxu se týkají jednoho spojení v jednom směru: od serveru k jednomu klientovi nebo od jednoho klienta k serveru.
- RemoteEventy jsou spolehlivé a seřazené. Ztracené zprávy se posílají znovu, dokud je příjemce připojený, a zprávy přicházejí v pořadí, ve kterém jste je poslali, i přes různé RemoteEventy. Pokud server pošle hráči A, pak B, pak A, tento hráč dostane A, B, A.
- Pořadí se týká okamžiku spuštění handlerů. Pokud handler pozastaví běh, například přes
task.waitneboWaitForChild, další zpráva se může začít zpracovávat dřív, než ta první skončí. - RemoteFunction a RemoteEvent nejsou seřazené vůči sobě. Pokud váš kód závisí na přísném pořadí, posílejte související zprávy jedním typem remotu, nebo přidejte vlastní pořadové číslo.
- Změny vlastností a atributů nejsou seřazené vůči remotům. Pokud server změní vlastnost a pak zavolá remote, klient může jako první vidět kterékoli z obou. Poslouchejte samotnou změnu, například přes
GetPropertyChangedSignal, a nespoléhejte na to, že už dorazila. - Handler ještě není. Zprávy RemoteEventu čekají ve frontě, dokud se handler nepřipojí. Fronta má meze: když je plná, další zprávy se zahodí a v Output se objeví chyba
Remote event invocation discarded. - Hráč, který odchází, ztratí všechny zprávy, které k němu ještě nedorazily.
Limit četnosti. Zprávy RemoteEventu a UnreliableRemoteEventu od klienta k serveru jsou omezené zhruba na 500 požadavků za sekundu na klienta, podle dokumentace k 30. září 2026. Limit je společný pro všechny remoty jednoho typu, takže rozdělení jednoho vytíženého remotu na deset ho nezvýší. Nad limitem se zprávy RemoteEventu zpracují později a zachovají pořadí, zatímco zprávy UnreliableRemoteEventu se zahodí. Limit enginu vůbec nebrání jednomu hráči volat váš remote 50krát za sekundu, takže každý handler, který něco mění, stejně potřebuje vlastní limit na hráče.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent, nebo atribut?
| Použijte | K čemu | Příklad | Na co si dát pozor |
|---|---|---|---|
| RemoteEvent | Zprávy jedním směrem, které musí dorazit, a v pořadí | Klient: „obarvi tento part“. Server: „ukaž toto oznámení“ | Kontrolujte každý argument na serveru |
RemoteFunction s InvokeServer | Klient potřebuje odpověď, než může pokračovat | Zadat promo kód, potvrdit nákup | Volající čeká; každá cesta musí vracet hodnotu |
RemoteFunction s InvokeClient | Skoro nikdy | Místo toho použijte FireClient | Klient, u kterého je chyba, který odešel nebo neodpověděl, rozbije nebo zasekne volání na serveru |
| UnreliableRemoteEvent | Časté aktualizace, kde je důležitá jen poslední | Směr míření, kosmetické efekty | Zprávy se ztrácejí nebo mění pořadí; limit dat 1000 bajtů |
| Atribut nebo value objekt nastavený serverem | Společný stav, který má být vidět vždy, i hráčům, kteří přišli později | Časovač kola, fáze hry, jestli jsou dveře otevřené | Ke všem se dostanou jen změny serveru; klienti poslouchají přes GetAttributeChangedSignal nebo Changed |
| BindableEvent | Komunikace skriptů na jedné straně | Jeden serverový skript oznámí druhému, že kolo skončilo | Nepřechází mezi serverem a klientem |
Celý příklad toho, jak RemoteFunction a kontroly spolupracují tam, kde hráči platí, najdete v návodu jak udělat GUI obchodu. Co se týče řádku o atributech, serverový skript z návodu ke dveřím nastavuje atribut Open na každých dveřích při každém jejich pohybu, takže na něj může reagovat jakýkoli LocalScript.
Časté chyby a řešení
Většina problémů s remoty je vidět v okně Output (otevřete ho z menu Window nebo z karty Script). Nejdřív se podívejte tam, pak níže najděte svůj příznak. Návod k chybám ve skriptech podrobněji rozebírá obecné chybové zprávy.
Infinite yield possible u WaitForChild pro remote
Skript čeká na remote, který se nikdy neobjeví. Ověřte, že název a velikost písmen přesně sedí a že remote leží v ReplicatedStorage, ne ve ServerStorage nebo ServerScriptService, které klienti nevidí.
Server dostává špatné hodnoty, posunuté o jednu
LocalScript předal samotného hráče, jako v remote:FireServer(player, 5). Roblox odesílatele přidává jako první parametr sám, takže server vidí (player, player, 5). Volejte remote:FireServer(5).
Když remote zavolám, nic se nestane
Ověřte, že každé volání jde ze správné strany: FireServer a InvokeServer fungují jen z klientského kódu a FireClient, FireAllClients a InvokeClient jen ze serverového Scriptu. LocalScript se nikdy nespustí v ServerScriptService, ServerStorage ani přímo ve Workspace; dávejte ho do StarterPlayerScripts, StarterGui, StarterCharacterScripts nebo StarterPack. Pak hledejte v Output chybu uvnitř handleru.
Remote event invocation discarded
Zprávy přišly pro RemoteEvent, který neměl připojený handler, a fronta se zaplnila. Obvykle skript s handlerem spadne s chybou před řádkem s :Connect, je vypnutý, nebo uvízl při čekání na něco, co se nikdy nenačte. Handlery připojujte blíž k začátku skriptu.
U mě to funguje, ale ostatní hráči změnu nevidí
Změna se udělala na klientu, v LocalScriptu nebo v handleru OnClientEvent. Udělejte ji v serverovém handleru OnServerEvent.
InvokeServer se nikdy nevrátí
Buď žádný skript nenastavil OnServerInvoke (Roblox drží volání ve frontě, dokud ho nikdo nenastaví), nebo callback uvízl na něčem, co pozastavuje běh, například na WaitForChild nebo požadavku na úložiště dat. Přidejte print na začátek a konec callbacku a uvidíte, kde se zastavuje.
Udělat s RoCode
Tohle může nastavit i RoCode, přímo ve vašem otevřeném place. RoCode je AI agent, který pracuje přes plugin pro Roblox Studio, takže vytváří remoty a skripty ve vašem Exploreru, místo aby vám dal kód k vložení.
Ať hráči barví party ve složce Paintable kliknutím. Použij RemoteEvent a nech kontroly na serveru: jen party z této složky, nejvýš 30 studů daleko a ne víc než pár obarvení za sekundu.
- Obvykle si nejdřív prohlédne place přes Search Game a Search Scripts kvůli hotové složce Remotes nebo handleru a použije vaše složky, pokud existují
- Vytvoří RemoteEvent v ReplicatedStorage přes Create Instance a napíše serverový Script a LocalScript přes Create Script
- Před dokončením ověří kompilaci každého skriptu přes Check Script uvnitř Studia. To chytá chyby kompilace, ne chyby logiky: nekontroluje typy, nespouští linter a váš kód nespouští
- Posílá změny po dávkách a každá dávka je bod pro vrácení v historii Studia
S pluginem 3.9 nebo novějším může RoCode spustit krátký playtest a přečíst chyby a s pluginem 3.9.11 nebo novějším ovládat testovací postavu, ale na party ve 3D okně neklikne. Klikněte na Play sami a zkuste kontroly rozbít, například obarvit part z druhého konce mapy. Pokud vznikne chyba, Check Output umí přečíst řádky Server a Client z vašeho posledního playtestu. Většina herních systémů komunikuje přes takové remoty, takže je potkáte znovu, až budete stavět hru systém po systému s RoCode. Jak se RoCode připojuje ke Studiu.
Časté otázky
Co v Robloxu znamená securing the client-server boundary?
Tak se jmenuje stránka dokumentace Robloxu o bezpečnosti remotů a myšlenka je jednoduchá: všechno, co klient pošle přes RemoteEvent nebo RemoteFunction, může pocházet od exploitera, proto to server zkontroluje, než začne jednat. Kontrolujte typ každého argumentu, držte čísla v rozumných mezích, ověřte, že hráč to teď smí dělat, a omezte, jak často může každý hráč remote volat. Kontrolní seznam výše ukazuje každou z kontrol v kódu.
Je bezpečné používat RemoteFunction?
InvokeServer je bezpečný tak, jak je bezpečný váš serverový callback: kontrolujte jeho argumenty a omezte četnost jako u každého RemoteEventu. Rizikový směr je InvokeClient, protože klient, u kterého je chyba, který odešel nebo nikdy nevrátil hodnotu, rozbije nebo zasekne volání na serveru.
Mohou exploiteři vidět a volat moje remoty?
Ano. Všechno, co leží v ReplicatedStorage, dorazí ke každému klientovi a upravený klient může zavolat jakýkoli remote s jakýmikoli argumenty. Přejmenování nebo schování remotů je bezpečnými nedělá; bezpečnými je dělá kontrola každého argumentu na serveru.
Může jeden klient poslat RemoteEvent jinému klientovi?
Přímo ne. Pošlete ho na server, tam ho zkontrolujte a pak použijte FireClient nebo FireAllClients.
Jak často se dá RemoteEvent volat?
Dokumentace Robloxu uvádí limit zhruba 500 požadavků za sekundu na klienta pro zprávy RemoteEventu a UnreliableRemoteEventu poslané na server, společný pro všechny remoty jednoho typu. Držte se hluboko pod ním a dejte každému handleru vlastní limit na hráče.
Dorazí FireAllClients k hráčům, kteří přišli později?
Ne. Dorazí k hráčům připojeným v tu chvíli. Pro stav, který potřebují opozdilci, nastavte na serveru atribut nebo value objekt.
Jaký je rozdíl mezi RemoteEvent a BindableEvent?
RemoteEvent přechází mezi serverem a klientem. BindableEvent spojuje skripty na jedné straně, například dva serverové skripty.
Zdroje a další čtení
- Roblox Creator Docs: Remote events and callbacks (anglicky). FireServer, FireClient, InvokeServer, rizika InvokeClient, omezení argumentů a záruky doručení
- Roblox Creator Docs: Securing the client-server boundary (anglicky). Úrovně kontroly, NaN, limity četnosti, přeposílání od klienta ke klientovi
- Roblox Creator Docs: Security and cheat mitigation tactics (anglicky). Co umí upravený klient a autorita serveru
- Roblox Creator Docs: Network ownership, movement validation, and physics (anglicky). Proč klient ovládá svou postavu a meze kontrol vzdálenosti
- Roblox Engine API: RemoteEvent (anglicky). Limit četnosti a chyba invocation discarded
- Roblox Engine API: RemoteFunction (anglicky). OnServerInvoke, varování k InvokeClient a opatření se streamingem
- Roblox Engine API: UnreliableRemoteEvent (anglicky). Limit dat 1000 bajtů
- Roblox Creator Docs: Properties and attributes (anglicky). Pořadí replikace mezi změnami vlastností a remote events
Jak byl kód ověřen: každý skript na této stránce prochází přísnou kontrolou typů Luau s definicemi Roblox API (luau-lsp, 20. listopadu 2026). Kontrola typů zachytí chyby v názvech API a špatné typy, ale ne chyby v herní logice, proto vše otestujte ve Studiu před publikováním.