Tutoriál · Základy skriptování

RemoteEvent v Robloxu: od klienta k serveru a zpět

LocalScript nemůže změnit to, co vidí ostatní hráči, a serverový Script nedosáhne na obrazovku jednoho hráče. Zprávy mezi nimi předávají RemoteEventy. V tomto návodu postavíme tři vzory, které budete potřebovat nejčastěji, RemoteFunction, která vrací odpověď, a kontroly na serveru, které zabrání upravenému klientovi je zneužít.

Aktualizováno 20. listopadu 202616 min čteníAutor:

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 (InvokeServer a OnServerInvoke), jen když klient potřebuje odpověď. Vyhněte se InvokeClient: 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
  1. K čemu jsou remoty
  2. Nastavení remotů
  3. 1. Od klienta k serveru
  4. 2. Od serveru klientovi
  5. 3. Od serveru všem
  6. RemoteFunction
  7. Kontrolní seznam
  8. Co nejde poslat
  9. Vrací nil?
  10. UnreliableRemoteEvent
  11. Pořadí a limity
  12. Co vybrat
  13. Common errors
  14. S RoCode
  15. Časté otázky
  16. Zdroje a další čtení

K čemu jsou RemoteEventy

IlustraceKaždé kliknutí požádá server, aby part obarvil, takže nová barva je vidět na obrazovkách obou hráčů.

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í.
Které volání spustí kterou událost
SměrOdesílatel voláPříjemce se připojí kPříjemce dostane
Od klienta k serveruremote:FireServer(...) v LocalScripturemote.OnServerEvent ve ScriptuPlayer, který zprávu poslal, pak vaše argumenty
Od serveru jednomu klientoviremote:FireClient(player, ...) ve Scripturemote.OnClientEvent v LocalScriptuJen vaše argumenty
Od serveru všem klientůmremote:FireAllClients(...) ve Scripturemote.OnClientEvent v LocalScriptuJen 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ě.

  1. V Exploreru najeďte myší na ReplicatedStorage, klikněte na tlačítko + a vložte Folder. Pojmenujte složku Remotes.
  2. Najeďte myší na Remotes, klikněte na + a vložte RemoteEvent. Přejmenujte ho tak, aby název popisoval účel, například PaintRequest.
  3. Zopakujte pro každý remote. Tento návod používá dva RemoteEventy (PaintRequest a Notify) a jednu RemoteFunction (RedeemCode).
Explorer: všechno, co tento návod přidává, část po části
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.

  1. Do Workspace vložte Folder s názvem Paintable a dejte do ní několik ukotvených Partů.
  2. Ověřte, že v ReplicatedStorage.Remotes je RemoteEvent s názvem PaintRequest.
  3. Vložte Script s názvem PaintServer do ServerScriptService a LocalScript s názvem PaintClient do StarterPlayer, StarterPlayerScripts, s kódem níže.
Script v ServerScriptService s názvem 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")

-- 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.

LocalScript v StarterPlayerScripts s názvem 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 -- 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.

Script v ServerScriptService s názvem WelcomeServer
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
LocalScript v StarterPlayerScripts s názvem NotifyClient
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.

Script v ServerScriptService s názvem 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 -- 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.

  1. Do ReplicatedStorage.Remotes vložte RemoteFunction s názvem RedeemCode.
  2. Do StarterGui vložte ScreenGui s názvem CodeGui a do něj TextBox s názvem CodeBox. Velikost a místo vyberte podle sebe.
  3. Přidejte Script níže do ServerScriptService a LocalScript dovnitř CodeBox.
Script v ServerScriptService s názvem RedeemServer
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.

LocalScript v TextBoxu CodeBox s názvem 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 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, InvokeClient hodí 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á.

Kontrolní seznam pro server
KontrolaOtázka, kterou si server kladePříklad
TypJe to typ, který čekám? Instance, ne tabulka postavená tak, aby ji připomínala?typeof(part) == "Instance" and part:IsA("BasePart")
RozsahJe čí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álenostJe postava hráče v serverové kopii světa dost blízko? Nechte malou rezervu na lagy.Nejvýš 30 studů od partu
ČetnostNeposí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.

ModuleScript v ServerScriptService s názvem RemoteGuard
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:

Script v ServerScriptService s názvem 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í:

Argumenty, které nepřijdou tak, jak byly odeslány
PosíláteCo se stane
FunkciDruhá strana dostane nil
Tabulku s metatabulkouMetatabulka 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íčiRoblox 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 functionTakové klíče se změní na řetězce
Instance, kterou příjemce nevidí, například ze ServerStorage nebo vytvořenou v LocalScriptuDruhá strana dostane nil
Jakoukoli tabulkuPří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ě:

  1. Cesta bez návratové hodnoty. Každý výstup z OnServerInvoke musí něco vracet. Prázdný return v rané kontrole pošle zpět nil.
  2. return uvnitř vnořené funkce. return uvnitř pcall(function() ... end), handleru :Connect nebo task.spawn vystoupí jen z této vnitřní funkce. Uložte výsledek, například local ok, data = pcall(...), a pak vraťte data ze samotného callbacku.
  3. 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í.
  4. 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.wait nebo WaitForChild, 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?

Jak vybrat způsob komunikace klienta a serveru
PoužijteK čemuPříkladNa co si dát pozor
RemoteEventZprá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 InvokeServerKlient potřebuje odpověď, než může pokračovatZadat promo kód, potvrdit nákupVolající čeká; každá cesta musí vracet hodnotu
RemoteFunction s InvokeClientSkoro nikdyMísto toho použijte FireClientKlient, 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é efektyZprávy se ztrácejí nebo mění pořadí; limit dat 1000 bajtů
Atribut nebo value objekt nastavený serveremSpoleč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
BindableEventKomunikace skriptů na jedné straněJeden serverový skript oznámí druhému, že kolo skončiloNepř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í.

Napíšete

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.

RoCode udělá
  • 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í

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.

Vyzkoušejte RoCode ve své hře.

Kredity zdarma každý den, bez karty. Nainstalujte plugin, popište funkci a podívejte se, co se objeví ve Studiu.