Návod · Základy skriptovania

RemoteEvent v Robloxe: od klienta k serveru a späť

LocalScript nemôže zmeniť to, čo vidia ostatní hráči, a serverový Script nedosiahne na obrazovku jedného hráča. Správy medzi nimi prenášajú RemoteEvent. V tomto návode poskladáme tri schémy, ktoré budete potrebovať najčastejšie, RemoteFunction, ktorá vracia odpoveď, a serverové kontroly, ktoré nedovolia upravenému klientovi ich zneužiť.

Aktualizované 20. novembra 202616 min čítaniaAutor:

V skratke

RemoteEvent je objekt, ktorý zvyčajne leží v ReplicatedStorage a prenáša správy cez hranicu medzi klientom a serverom. LocalScript zavolá FireServer a server dostane správu v OnServerEvent, kde je ako prvý argument pridaný Player, ktorý ju poslal. Server zavolá FireClient(player, ...) alebo FireAllClients(...) a LocalScripty dostanú správu v OnClientEvent.

  • Používajte RemoteFunction (InvokeServer a OnServerInvoke), len keď klient potrebuje odpoveď. Vyhnite sa InvokeClient: klient, u ktorého nastala chyba, ktorý odišiel alebo nikdy nevrátil hodnotu, pokazí volanie na serveri.
  • Nikdy neverte tomu, čo posiela klient. Na serveri kontrolujte typ, rozsah a vlastníctvo každého argumentu, vzdialenosť od hráča a to, ako často remote volá.
  • Funkcie, metatabuľky a objekty, ktoré druhá strana nevidí, prenos neprežijú. UnreliableRemoteEvent môže správy strácať alebo meniť ich poradie a zahodí akékoľvek dáta väčšie než 1000 bajtov.
Na tejto stránke
  1. Na čo sú remoty
  2. Nastavenie remotov
  3. 1. Od klienta k serveru
  4. 2. Od servera klientovi
  5. 3. Od servera všetkým
  6. RemoteFunction
  7. Kontrolný zoznam
  8. Čo sa nedá poslať
  9. Vracia nil?
  10. UnreliableRemoteEvent
  11. Poradie a limity
  12. Čo vybrať
  13. Common errors
  14. S RoCode
  15. Časté otázky
  16. Zdroje a ďalšie čítanie

Na čo slúžia RemoteEvent

IlustráciaKaždý klik požiada server, aby part zafarbil, preto je nová farba vidieť na obrazovkách oboch hráčov.

Každá hra v Robloxe beží ako jeden server plus jeden klient pre každého hráča. Hlavný je tu server: nový objekt alebo zmena vlastnosti sa dostane ku všetkým hráčom, len keď ju urobí server. Zmena urobená v LocalScript zostane na jednom zariadení, až na niekoľko výnimiek, ako je vlastná postava hráča, ktorej pohyb ovláda jeho klient. Preto keď má klik alebo stlačenie klávesu zmeniť spoločný svet, klient musí server požiadať, a keď server chce, aby zareagovala obrazovka jedného hráča, musí to klientovi oznámiť. Ak je pre vás rozdelenie na Script a LocalScript novinka, najprv si prečítajte Script vs LocalScript vs ModuleScript (po anglicky). Ak je pre vás novinka samotné skriptovanie, začnite tým, ako písať skripty v Roblox Studiu.

Na prekročenie tejto hranice dáva Roblox tri objekty:

  • RemoteEvent: správa jedným smerom. Odosielateľ hneď pokračuje v práci.
  • RemoteFunction: požiadavka, ktorá čaká na odpoveď. Volajúci kód stojí, kým druhá strana nevráti hodnotu.
  • UnreliableRemoteEvent: správa jedným smerom, ktorá sa môže stratiť alebo prísť mimo poradia, zato menej zaťažuje sieť. Hodí sa pre dáta, ktoré sa neustále menia.
Ktoré volanie spúšťa ktorú udalosť
SmerOdosielateľ voláPríjemca sa pripája kPríjemca dostane
Od klienta k serveruremote:FireServer(...) v LocalScriptremote.OnServerEvent v ScriptPlayer, ktorý správu poslal, potom vaše argumenty
Od servera jednému klientoviremote:FireClient(player, ...) v Scriptremote.OnClientEvent v LocalScriptLen vaše argumenty
Od servera všetkým klientomremote:FireAllClients(...) v Scriptremote.OnClientEvent v LocalScriptLen vaše argumenty
Klient sa pýta, server odpovedáremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player, potom vaše argumenty. Volajúci dostane to, čo funkcia vrátila

Klienti si nemôžu posielať správy priamo. Ak chcete odovzdať niečo od jedného hráča ostatným, pošlite to na server, skontrolujte to tam a nech to server prepošle ďalej cez FireClient alebo FireAllClients. Podľa bezpečnostných odporúčaní Robloxu funguje server ako vrátnik, nie ako obyčajný prenášač.

Kde mať remoty

Remote musí ležať tam, kde ho vidí server aj klienti. Bežné miesto je ReplicatedStorage; dokumentácia Robloxu uvádza, že v niektorých prípadoch sa hodí aj Workspace alebo Tool. ServerStorage a ServerScriptService sú dostupné len serveru, preto LocalScript, ktorý odtiaľ čaká na remote, bude čakať večne.

  1. V Exploreri prejdite kurzorom na ReplicatedStorage, kliknite na tlačidlo + a vložte Folder. Pomenujte priečinok Remotes.
  2. Prejdite kurzorom na Remotes, kliknite na + a vložte RemoteEvent. Premenujte ho tak, aby názov opisoval účel, napríklad PaintRequest.
  3. Zopakujte to pre každý remote. Tento návod používa dva RemoteEvent (PaintRequest a Notify) a jednu RemoteFunction (RedeemCode).
Explorer: všetko, čo pridáva tento návod, časť po časti
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ávode hľadajú remoty cez WaitForChild. Vráti výsledok hneď, ak je remote už na mieste, a čaká, ak ešte nie je, napríklad keď serverový skript vytvára remoty počas hry. Pre každý druh požiadavky majte samostatný remote: potom každý serverový handler kontroluje jeden tvar argumentov a urobiť to správne je oveľa jednoduchšie než s jedným remotom na všetko.

Schéma 1: od klienta k serveru, s kontrolou na serveri

Najčastejšia úloha: hráč niečo urobí na svojej obrazovke a server rozhodne, čo sa stane. Tu hráč stlačí Q, aby vybral jednu zo štyroch farieb, a klikne alebo ťukne na part, aby ho zafarbil. Novú farbu vidia všetci, pretože farbí server.

Klient posiela dve veci: ktorý part a číslo farby. Samotnú farbu neposiela nikdy a v iných hrách presne tak isto nemá posielať cenu, odmenu ani veľkosť poškodenia. Upravený klient môže poslať čokoľvek, preto skutočné dáta (tu je to paleta) má server a argumenty berie ako požiadavku, ktorú treba skontrolovať.

  1. Vo Workspace vložte Folder s názvom Paintable a dajte doň niekoľko ukotvených Partov.
  2. Skontrolujte, že v ReplicatedStorage.Remotes je RemoteEvent s názvom PaintRequest.
  3. Vložte Script s názvom PaintServer do ServerScriptService a LocalScript s názvom PaintClient do StarterPlayer, StarterPlayerScripts, s kódom nižšie.
Script v ServerScriptService s názvom 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")

-- Farby patria serveru. Klient posiela len číslo, ktoré jednu z nich vyberie.
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 -- studov medzi postavou a partom
local COOLDOWN_SECONDS = 0.25

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

-- Prvý parameter je vždy hráč, ktorý remote zavolal. Dosadí ho Roblox,
-- preto mu možno veriť. Všetko za ním prišlo od klienta a tomu veriť nemožno.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Typ: skutočný part, nie tabuľka, ktorá sa zaňho vydáva
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Rozsah: celé číslo od 1 do 4. NaN a nekonečno sa tiež odfiltrujú tu.
	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ý cieľ: len party v priečinku Paintable, nič iné v hre
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Vzdialenosť: postava hráča musí byť pri parte
	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 frekvencie: jedno zafarbenie na hráča raz za štvrť 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á neúspešná kontrola jednoducho urobí return. Vysvetľovať podvádzajúcemu klientovi, prečo bol odmietnutý, nemá zmysel.

LocalScript v StarterPlayerScripts s názvom 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 -- skutočné farby má server
local selectedColour = 1

-- Lúč môže zasiahnuť len party vnútri priečinka 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áves alebo klik išiel do chatu alebo na tlačidlo
	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
			-- Žiadame, nerozkazujeme: či farbiť, rozhodne server
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed je true, keď engine už tento vstup spracoval, zvyčajne v rozhraní: klik na tlačidlo alebo klávesy napísané do textového poľa, napríklad do riadku chatu. Vďaka tejto kontrole písmeno Q napísané v správe nezmení farbu.

Schéma 2: od servera jednému klientovi

Server posiela správu jednému hráčovi cez FireClient. Prvý argument je Player, ktorému je určená, a handler na klientovi dostane len argumenty za ním. Používajte to na všetko osobné: upozornenie, okno s odmenou, zvuk, ktorý má počuť len tento hráč. Návod na cutscény je väčší rozobraný príklad: server rozhodne, kedy hráč uvidí cutscénu, a pošle jej snímky tomuto jednému hráčovi cez FireClient, pričom kameru hýbe jeho zariadenie.

Táto dvojica skriptov zobrazí privítanie, keď hráč príde. LocalScript si sám poskladá malý banner, takže GUI netreba nastavovať.

Script v ServerScriptService s názvom WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local function welcome(player: Player)
	-- Prvý argument vyberá, ktorý klient správu dostane. Nikto iný ju neuvidí.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- V Studiu sa dá pripojiť skôr, než sa tento skript pripojí, preto privítame všetkých, čo už sú tu
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript v StarterPlayerScripts s názvom 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 hore na obrazovke, poskladaný v kóde
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 je parameter player: server už vybral, kto sprá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, ak ju nenahradila novšia správa
			label.Visible = false
		end
	end)
end)

Server posiela správu pri PlayerAdded, a to sa môže stať skôr, než tento LocalScript pripojí svoj handler. To je v poriadku: Roblox zaradí do frontu správy RemoteEvent, ktoré prišli pred pripojením handlera, a doručí ich v poradí, hneď ako sa handler pripojí.

Klient sa nemusí brániť pred serverom: OnClientEvent môže spustiť len serverový kód. Anotácia message: string slúži na kontrolu typov; nie je to kontrola počas behu.

Schéma 3: od servera všetkým klientom

FireAllClients pošle tú istú správu každému pripojenému hráčovi. Nemá argument Player a každý klient dostane správu v tom istom OnClientEvent ako predtým, takže skript NotifyClient zo schémy 2 ju už zobrazuje.

Tento Script oznámi všetkým, keď sa hráč prvýkrát dotkne cieľovej čiary. Pridajte do Workspace ukotvený Part s názvom FinishLine, potom pridajte Script do ServerScriptService.

Script v ServerScriptService s názvom FinishAnnouncer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local finishLine = workspace:WaitForChild("FinishLine") :: BasePart

local finished: { [Player]: boolean } = {}

finishLine.Touched:Connect(function(hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not player or finished[player] then
		return -- nie je to hráč alebo už bol oznámený
	end
	finished[player] = true

	-- Každý pripojený klient spustí svoj handler OnClientEvent s týmto textom
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

Exploiter môže vyvolať Touched pre svoju postavu z akejkoľvek vzdialenosti, ale pri oznámení, ktoré sa zobrazí raz na hráča, je to neškodné. Ak budete neskôr za cieľ dávať odmenu, pridajte pred jej udelením serverové kontroly, napríklad minimálny čas od začiatku kola.

FireAllClients sa dostane len k hráčom pripojeným v danej chvíli. Kto príde o sekundu neskôr, správu už neuvidí. To sa hodí na jednorazové momenty, ako je oznámenie, efekt výbuchu alebo zvuk, ale nehodí sa na stav, ako je časovač kola alebo aktuálna fáza hry. Pre stav nastavte na serveri atribút, napríklad ReplicatedStorage:SetAttribute("TimeLeft", 30), a čítajte ho na klientovi cez GetAttribute a GetAttributeChangedSignal("TimeLeft"). Atribúty sa replikujú každému klientovi, vrátane hráčov, ktorí prišli neskôr.

RemoteFunction: keď klient potrebuje odpoveď

RemoteEvent funguje na princípe „pošli a zabudni“. RemoteFunction prinúti volajúceho čakať: InvokeServer pozastaví kód, ktorý ho zavolal, kým serverová funkcia OnServerInvoke nevráti hodnotu, a potom odovzdá to, čo vrátila. Použite ju, keď klient nemôže pokračovať bez odpovede, napríklad „bol tento kód správny?“. Keď odpoveď netreba, Roblox odporúča RemoteEvent, pretože nečaká.

Príklad: pole, kam hráči zadávajú promo kód. Server má kódy, skontroluje text a vráti dve hodnoty: či to fungovalo a správu, ktorú treba zobraziť.

  1. Do ReplicatedStorage.Remotes vložte RemoteFunction s názvom RedeemCode.
  2. Do StarterGui vložte ScreenGui s názvom CodeGui a doň TextBox s názvom CodeBox. Veľkosť a umiestnenie vyberte podľa seba.
  3. Pridajte Script nižšie do ServerScriptService a LocalScript dovnútra CodeBox.
Script v ServerScriptService s názvom RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Kódy žijú na serveri, kde ich žiadny hráč nemôže prečítať
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 } = {}

-- Priraďujeme cez =. OnServerInvoke je callback, nie udalosť, ku ktorej sa robí 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)

Pripočítava k štatistike Coins z návodu na leaderboard. Použité kódy si pamätá len do odchodu hráča, takže v tejto podobe sa hráč môže znova pripojiť a zadať ten istý kód znova. Ak sa mince ukladajú, sú to mince zadarmo pri každom opätovnom pripojení: skôr než to použijete v živej hre, ukladajte použité kódy každého hráča spolu s jeho uloženými dátami v úložisku dát.

LocalScript v TextBox CodeBox s názvom 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 pozastaví túto funkciu, kým callback servera nevráti hodnotu.
	-- pcall zabráni zastaveniu LocalScriptu, ak volanie zlyhalo.
	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á presne jeden serverový callback. Ak dva skripty nastavia OnServerInvoke tej istej RemoteFunction, funguje len posledný.

Prečo je InvokeClient nebezpečný

RemoteFunction funguje aj opačným smerom, s InvokeClient na serveri a OnClientInvoke na klientovi. Dokumentácia Robloxu uvádza tri vážne riziká:

  • Ak callback klienta vyhodí chybu, server tiež vyhodí chybu.
  • Ak hráč počas volania odíde, InvokeClient vyhodí chybu.
  • Ak klient nikdy nevráti hodnotu, serverový skript bude čakať večne.

Upravený klient ovláda svoj callback, preto podvodník môže zámerne vyvolať tretí prípad a držať tento serverový thread, ako dlho chce. Na aktualizáciu obrazovky hráča použite FireClient. Ak server naozaj potrebuje informáciu od klienta, pošlite RemoteEvent, nech klient odpovie cez iný RemoteEvent, a chýbajúcu odpoveď berte na serveri ako bežný prípad.

Kontrolujte každý argument na serveri

Exploiter môže zavolať akýkoľvek RemoteEvent alebo akúkoľvek RemoteFunction ľubovoľne veľakrát a s ľubovoľnými argumentmi. Jediné, čo nemôže sfalšovať, je prvý parameter: Roblox sám dosadí Player, ktorý správu poslal. Všetko, čo nasleduje, treba skontrolovať, skôr než server začne konať. Skrývať remote alebo kontrolovať v LocalScript je zbytočné, pretože podvodník ovláda svojho klienta.

Kontrolný zoznam pre server
KontrolaOtázka, ktorú si server kladiePríklad
TypJe to typ, ktorý čakám? Instance, a nie tabuľka poskladaná tak, aby sa naň podobala?typeof(part) == "Instance" and part:IsA("BasePart")
RozsahJe číslo konečné a v povolených medziach? Má text rozumnú dĺžku?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
VlastníctvoVlastní tento hráč predmet, má dosť peňazí, má právo s týmto objektom narábať?Predmet je v jeho inventári; part leží vnútri Paintable
VzdialenosťJe postava hráča v serverovej kópii sveta dosť blízko? Nechajte malú rezervu na lag.Najviac 30 studov od partu
FrekvenciaNeposiela tento hráč príliš často?Cooldown na hráča alebo limit s hromadením volaní

NaN si zaslúži osobitné varovanie. Je to číslo, takže type(x) == "number" prejde, ale každé porovnanie s ním dáva false a kontrola ako x < 0 or x > 100 ho prepustí. math.isfinite(x) odmietne NaN aj obe nekonečná.

Pamätajte na hranice kontroly vzdialenosti. Každý klient ovláda fyziku svojej postavy, preto exploiter môže pred volaním presunúť postavu k cieľu. Kontrola aj tak zastaví najjednoduchšie zneužitie, keď niekto z jedného miesta pôsobí na celú mapu. Cieľové party majte ukotvené: bezpečnostná dokumentácia Robloxu uvádza, že exploiter môže získať sieťové vlastníctvo neukotvených partov pri sebe a pritiahnuť si ich bližšie, čím obíde kontrolu vzdialenosti.

Tu sú tie isté kontroly ako ModuleScript, ktorý môžete použiť v každom handleri remotu.

ModuleScript v ServerScriptService s názvom RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Skutočné číslo medzi min a max. Odmieta NaN a nekonečno, ktoré prejdú
-- obyčajnou 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 medzi min a max, pre množstvá, indexy a počítadlá
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 obmedzenou dĺžkou. utf8.len vracia nil pre neplatné UTF-8, ktoré
-- úložiská dát odmietajú.
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čakávanej triedy vnútri kontajnera, ktorý ste povolili.
-- Tabuľka poskladaná tak, aby sa podobala na Instance, kontrolou typeof neprejde.
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, keď je postava hráča najviac maxDistance studov 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 frekvencie na hráča. Každý hráč môže urobiť `burst` volaní naraz a
-- dostane späť `perSecond` volaní každú sekundu. Vracia funkciu, ktorá sa volá
-- pred prácou: odpovie true (možno) alebo false (prí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

Majte ho v ServerScriptService. Kód odtiaľ sa nikdy nedostane ku klientom, takže vaše kontroly nikto neprečíta.

A tu je handler zo schémy 1 prepísaný s jeho pomocou. Nahraďte obsah PaintServer:

Script v ServerScriptService s názvom PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" je dôležité len pre prísnu kontrolu typov Luau; počas behu nič nemení
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, potom 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 vymaže záznam hráča, keď odíde, takže jeho tabuľka nerastie celý čas, čo server beží.

Pri zbraniach sú tieto kontroly najdôležitejšie: nikdy nedovoľte klientovi hlásiť, koho zasiahol. Remote z návodu na meč nenesie vôbec žiadne argumenty a server nájde ciele sám. Návod na zbraň posiela len bod mierenia, ktorý server skontroluje na typ, NaN a vzdialenosť, skôr než vyšle vlastný lúč.

Menu sa riadia tým istým pravidlom: posielajte voľbu, nie výsledok. V návode na dialógy s NPC klient posiela len číslo stlačeného tlačidla a server sám zistí, čo táto odpoveď dáva. Menu z návodu na teleporty posiela názov bodu, nie pozíciu, a server nájde bod vo svojom priečinku a skontroluje, koľko Wins preň treba.

Čo sa dá a čo sa nedá posielať

Posielať môžete čísla, reťazce, booleovské hodnoty, typy Robloxu ako Vector3, CFrame, Color3 a položky Enum, Instance, ktoré vidia obe strany, a tabuľky zo všetkého tohto. Niektoré hodnoty sa po ceste menia alebo strácajú:

Argumenty, ktoré neprídu také, aké boli poslané
PošleteČo sa stane
FunkciuDruhá strana dostane nil
Tabuľku s metatabuľkouMetatabuľka sa stratí spolu so všetkým, čo tabuľka mala len cez ňu
Tabuľku, kde sú zmiešané číselné a reťazcové kľúčeRoblox radí to nerobiť: posielajte čisté pole alebo čistý slovník
Tabuľku s hodnotami nil vnútriVyhnite sa tomu: Roblox neodporúča nil na žiadnom indexe
Tabuľku s kľúčmi typu Instance, userdata alebo functionTakéto kľúče sa zmenia na reťazce
Instance, ktorý príjemca nevidí, napríklad zo ServerStorage alebo vytvorený v LocalScriptDruhá strana dostane nil
Akúkoľvek tabuľkuPríjemca dostane kópiu, nie tú istú tabuľku

Dobrý zvyk: posielať identifikátory, nie objekty alebo hodnoty. Názov predmetu, číslo možnosti, part, ktorý server dokáže nájsť a skontrolovať. Ďalej server pracuje so svojimi dátami.

Prečo RemoteFunction vracia nil

Ak vám InvokeServer vracia nil, prejdite tieto body po poradí:

  1. Cesta bez návratovej hodnoty. Každý výstup z OnServerInvoke musí niečo vracať. Prázdny return v skorej kontrole pošle späť nil.
  2. return vnútri vnorenej funkcie. return vnútri pcall(function() ... end), handlera :Connect alebo task.spawn vyskočí len z tejto vnútornej funkcie. Uložte výsledok, napríklad local ok, data = pcall(...), a potom vráťte data zo samotného callbacku.
  3. Hodnota, ktorá nemôže prekročiť hranicu. Funkcia alebo Instance, ktorý klient nevidí (napríklad čokoľvek v ServerStorage), príde ako nil. So zapnutým instance streaming sa part, ktorý server práve vytvoril, nemusel ku klientovi dostať v čase návratu z funkcie.
  4. Callback nastavil iný skript. Funguje len posledné priradenie OnServerInvoke. Vyhľadajte názov remotu vo svojich skriptoch.

Ak sa volanie vôbec nevráti, žiadny skript ešte nenastavil OnServerInvoke (Roblox drží volania vo fronte, kým ho niekto nenastaví) alebo callback visí, napríklad na WaitForChild pre niečo, čo sa nikdy neobjaví.

UnreliableRemoteEvent: pre neustále jednorazové aktualizácie

UnreliableRemoteEvent má tie isté metódy a udalosti ako RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent a OnClientEvent. Rozdiel je v tom, že Roblox nezaručuje ani doručenie, ani poradie. Správa môže byť zahodená bez opätovného odoslania, keď:

  • sa stratí po ceste alebo príliš dlho čaká v preťaženej sieti
  • jej dáta sú väčšie než 1000 bajtov
  • klient posiela častejšie, než dovoľuje limit (nadbytok sa zahodí, neodloží)
  • v čase príchodu nie je pripojený žiadny handler (zahodí sa, nezaradí sa do frontu)

Správy môžu prichádzať aj mimo poradia a ich poradie nijako nesúvisí s vašimi RemoteEvent alebo RemoteFunction. Používajte ho, keď je dôležitá len najčerstvejšia hodnota a ďalšia aktualizácia príde o zlomok sekundy: kam hráč mieri, pozícia kozmetického efektu, hodnota, ktorá sa mení každý snímok. Ak na poradí záleží, dajte do každej správy poradové číslo alebo časovú značku a ignorujte všetko staršie než posledná spracovaná.

Nikdy ho nepoužívajte na to, čo sa má stať presne raz, napríklad na nákup, poškodenie, odmenu alebo štart kola. A jeho argumenty kontrolujte na serveri presne tak ako pri RemoteEvent.

Poradie doručenia a limity frekvencie

Záruky doručenia v Robloxe sa týkajú jedného spojenia jedným smerom: od servera k jednému klientovi alebo od jedného klienta k serveru.

  • RemoteEvent sú spoľahlivé a usporiadané. Stratené správy sa posielajú znova, kým príjemca zostáva pripojený, a správy prichádzajú v poradí, v akom ste ich poslali, aj cez rôzne RemoteEvent. Ak server pošle hráčovi A, potom B, potom A, tento hráč dostane A, B, A.
  • Poradie sa týka okamihu spustenia handlerov. Ak handler prepustí riadenie, napríklad cez task.wait alebo WaitForChild, ďalšia správa sa môže začať spracúvať skôr, než skončí prvá.
  • RemoteFunction a RemoteEvent nie sú usporiadané navzájom. Ak váš kód závisí od presného poradia, posielajte súvisiace správy cez jeden typ remotu alebo pridajte vlastné poradové číslo.
  • Zmeny vlastností a atribútov nie sú usporiadané voči remotom. Ak server zmení vlastnosť a potom zavolá remote, klient môže ako prvé uvidieť ktorékoľvek z dvoch. Počúvajte samotnú zmenu, napríklad cez GetPropertyChangedSignal, a nespoliehajte sa, že už prišla.
  • Handler ešte neexistuje. Správy RemoteEvent čakajú vo fronte, kým sa handler nepripojí. Front má hranice: keď je plný, ďalšie správy sa zahodia a v Output sa objaví chyba Remote event invocation discarded.
  • Hráč, ktorý odchádza, stratí všetky správy, ktoré sa k nemu ešte nestihli dostať.

Limit frekvencie. Správy RemoteEvent a UnreliableRemoteEvent od klienta k serveru sú obmedzené približne na 500 požiadaviek za sekundu na klienta, podľa dokumentácie k 30. septembru 2026. Limit je spoločný pre všetky remoty jedného typu, takže rozdelenie jedného vyťaženého remotu na desať ho nezvýši. Nad limit sa správy RemoteEvent spracujú neskôr a zachovajú poradie, kým správy UnreliableRemoteEvent sa zahodia. Limit enginu vôbec nebráni jednému hráčovi volať váš remote 50-krát za sekundu, preto každý handler, ktorý niečo mení, aj tak potrebuje vlastný limit na hráča.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent alebo atribút?

Ako vybrať spôsob komunikácie klienta a servera
PoužiteNa čoPríkladNa čo si dať pozor
RemoteEventSprávy jedným smerom, ktoré musia prísť, a to v poradíKlient: „zafarbi tento part“. Server: „zobraz toto upozornenie“Kontrolujte každý argument na serveri
RemoteFunction s InvokeServerKlient potrebuje odpoveď, skôr než môže pokračovaťZadať promo kód, potvrdiť nákupVolajúci čaká; každá cesta musí vracať hodnotu
RemoteFunction s InvokeClientTakmer nikdyNamiesto toho použite FireClientKlient, u ktorého nastala chyba, ktorý odišiel alebo neodpovedal, pokazí alebo zavesí volanie na serveri
UnreliableRemoteEventČasté aktualizácie, kde je dôležitá len poslednáSmer mierenia, kozmetické efektySprávy sa strácajú alebo menia poradie; limit dát 1000 bajtov
Atribút alebo value objekt nastavený serveromSpoločný stav, ktorý musí byť vidieť vždy, aj pre hráčov, ktorí prišli neskôrČasovač kola, fáza hry, či sú dvere otvorenéKu všetkým sa dostanú len zmeny servera; klienti počúvajú cez GetAttributeChangedSignal alebo Changed
BindableEventKomunikácia skriptov na tej istej straneJeden serverový skript oznámi druhému, že kolo skončiloNeprechádza medzi serverom a klientom

Celý príklad toho, ako RemoteFunction a kontroly spolupracujú tam, kde hráči platia, nájdete v návode ako urobiť GUI obchodu. Čo sa týka riadku o atribútoch, serverový skript z návodu na dvere nastavuje atribút Open na každých dverách pri každom ich pohybe, takže naň môže reagovať akýkoľvek LocalScript.

Časté chyby a riešenia

Väčšinu problémov s remotmi uvidíte v okne Output (otvorte ho z menu Window alebo z karty Script). Najprv sa pozrite tam, potom nájdite svoj príznak nižšie. Návod na chyby v skriptoch podrobnejšie rozoberá všeobecné chybové hlásenia.

Infinite yield possible pri WaitForChild pre remote

Skript čaká na remote, ktorý sa nikdy neobjaví. Skontrolujte, že názov aj veľkosť písmen sa zhodujú presne a že remote leží v ReplicatedStorage, nie v ServerStorage alebo ServerScriptService, ktoré klienti nevidia.

Server dostáva nesprávne hodnoty, posunuté o jednu

LocalScript odovzdal samotného hráča, ako v remote:FireServer(player, 5). Roblox aj tak pridáva odosielateľa ako prvý parameter, takže server vidí (player, player, 5). Volajte remote:FireServer(5).

Keď zavolám remote, nič sa nestane

Skontrolujte, že každé volanie ide zo správnej strany: FireServer a InvokeServer fungujú len z klientskeho kódu a FireClient, FireAllClients a InvokeClient len zo serverového Script. LocalScript sa nikdy nespustí v ServerScriptService, ServerStorage ani priamo vo Workspace; dajte ho do StarterPlayerScripts, StarterGui, StarterCharacterScripts alebo StarterPack. Potom v Output vyhľadajte chybu vnútri handlera.

Remote event invocation discarded

Správy prišli pre RemoteEvent, ktorý nemal pripojený handler, a front sa zaplnil. Zvyčajne skript s handlerom spadne s chybou pred riadkom s :Connect, je vypnutý alebo visí pri čakaní na niečo, čo sa nikdy nenačíta. Pripájajte handlery bližšie k začiatku skriptu.

U mňa to funguje, ale ostatní hráči zmenu nevidia

Zmena je urobená na klientovi, v LocalScript alebo v handleri OnClientEvent. Urobte ju v serverovom handleri OnServerEvent.

InvokeServer sa nikdy nevráti

Buď žiadny skript nenastavil OnServerInvoke (Roblox drží volania vo fronte, kým ho niekto nenastaví), alebo callback visí na niečom, čo prepúšťa riadenie, napríklad na WaitForChild alebo požiadavke na úložisko dát. Pridajte print na začiatok a koniec callbacku, aby ste videli, kde sa zastaví.

Urobiť s RoCode

Toto môže nastaviť aj RoCode, priamo vo vašom otvorenom place. RoCode je AI agent, ktorý pracuje cez plugin pre Roblox Studio, preto vytvára remoty a skripty vo vašom Exploreri, namiesto toho, aby vám dal kód na vkladanie.

Napíšete

Nech hráči farbia party v priečinku Paintable klikom. Použi RemoteEvent a nechaj kontroly na serveri: len party z tohto priečinka, najviac 30 studov a nie viac než niekoľko zafarbení za sekundu.

RoCode urobí
  • Zvyčajne si najprv prezrie place cez Search Game a Search Scripts, či tam už nie je priečinok Remotes alebo handler, a použije vaše priečinky, ak existujú
  • Vytvorí RemoteEvent v ReplicatedStorage cez Create Instance a napíše serverový Script a LocalScript cez Create Script
  • Pred dokončením overí kompiláciu každého skriptu cez Check Script v Studiu. To zachytí chyby kompilácie, nie chyby logiky: nekontroluje typy, nespúšťa linter a nevykonáva váš kód
  • Posiela zmeny v dávkach a každá dávka je bod na vrátenie v histórii Studia

S pluginom 3.9 alebo novším môže RoCode spustiť krátky playtest a prečítať chyby a s pluginom 3.9.11 alebo novším môže ovládať testovaciu postavu, ale na party v 3D okne neklikne. Stlačte Play sami a skúste kontroly prelomiť, napríklad zafarbením partu z druhého konca mapy. Ak vznikne chyba, Check Output dokáže prečítať riadky Server a Client z vášho posledného playtestu. Väčšina herných systémov komunikuje cez takéto remoty, preto sa s nimi stretnete znova, keď budete stavať hru systém po systéme s RoCode. Ako sa RoCode pripája k Studiu.

Časté otázky

Čo znamená securing the client-server boundary v Robloxe?

Tak sa volá stránka dokumentácie Robloxu o bezpečnosti remotov a myšlienka je jednoduchá: všetko, čo klient posiela cez RemoteEvent alebo RemoteFunction, môže pochádzať od exploitera, preto to server skontroluje, skôr než začne konať. Kontrolujte typ každého argumentu, držte čísla v rozumných medziach, overte, že hráč to práve smie urobiť, a obmedzte, ako často môže každý hráč remote volať. Kontrolný zoznam vyššie ukazuje každú z nich v kóde.

Je bezpečné používať RemoteFunction?

InvokeServer je taký bezpečný, aký bezpečný je váš serverový callback: kontrolujte jeho argumenty a obmedzte frekvenciu ako pri každom RemoteEvent. Rizikový smer je InvokeClient, pretože klient, u ktorého nastala chyba, ktorý odišiel alebo nikdy nevrátil hodnotu, pokazí alebo zavesí volanie na serveri.

Môžu exploiteri vidieť a volať moje remoty?

Áno. Všetko, čo leží v ReplicatedStorage, sa dostane ku každému klientovi a upravený klient môže zavolať akýkoľvek remote s akýmikoľvek argumentmi. Premenovanie alebo skrytie remotov ich nerobí bezpečnými; bezpečnými ich robí kontrola každého argumentu na serveri.

Môže jeden klient poslať RemoteEvent inému klientovi?

Priamo nie. Pošlite ho na server, skontrolujte ho tam, potom použite FireClient alebo FireAllClients.

Ako často sa dá volať RemoteEvent?

Dokumentácia Robloxu uvádza limit približne 500 požiadaviek za sekundu na klienta pre správy RemoteEvent a UnreliableRemoteEvent poslané na server, spoločný pre všetky remoty jedného typu. Držte sa hlboko pod ním a dajte každému handleru vlastný limit na hráča.

Dostane sa FireAllClients k hráčom, ktorí prišli neskôr?

Nie. Dostane sa k hráčom pripojeným v danej chvíli. Pre stav, ktorý potrebujú oneskorení hráči, nastavte na serveri atribút alebo value objekt.

Aký je rozdiel medzi RemoteEvent a BindableEvent?

RemoteEvent prechádza medzi serverom a klientom. BindableEvent spája skripty na tej istej strane, napríklad dva serverové skripty.

Zdroje a ďalšie čítanie

Ako bol kód overený: každý skript na tejto stránke prechádza prísnou kontrolou typov Luau s definíciami Roblox API (luau-lsp, 20. novembra 2026). Kontrola typov zachytí chyby v názvoch API a nesprávne typy, ale nie chyby v hernej logike, preto všetko pred publikovaním otestujte v Studiu.

Vyskúšajte RoCode vo svojej hre.

Kredity zadarmo každý deň, bez karty. Nainštalujte plugin, opíšte funkciu a pozrite sa, čo sa objaví v Studiu.