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 (
InvokeServeraOnServerInvoke), len keď klient potrebuje odpoveď. Vyhnite saInvokeClient: 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
Na čo slúžia RemoteEvent
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.
| Smer | Odosielateľ volá | Príjemca sa pripája k | Príjemca dostane |
|---|---|---|---|
| Od klienta k serveru | remote:FireServer(...) v LocalScript | remote.OnServerEvent v Script | Player, ktorý správu poslal, potom vaše argumenty |
| Od servera jednému klientovi | remote:FireClient(player, ...) v Script | remote.OnClientEvent v LocalScript | Len vaše argumenty |
| Od servera všetkým klientom | remote:FireAllClients(...) v Script | remote.OnClientEvent v LocalScript | Len 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.
- V Exploreri prejdite kurzorom na ReplicatedStorage, kliknite na tlačidlo + a vložte Folder. Pomenujte priečinok
Remotes. - Prejdite kurzorom na
Remotes, kliknite na + a vložte RemoteEvent. Premenujte ho tak, aby názov opisoval účel, napríkladPaintRequest. - Zopakujte to pre každý remote. Tento návod používa dva RemoteEvent (
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á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ť.
- Vo Workspace vložte Folder s názvom
Paintablea dajte doň niekoľko ukotvených Partov. - Skontrolujte, že v
ReplicatedStorage.Remotesje RemoteEvent s názvomPaintRequest. - Vložte Script s názvom
PaintServerdo ServerScriptService a LocalScript s názvomPaintClientdo StarterPlayer, StarterPlayerScripts, s kódom nižšie.
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.
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ť.
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
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.
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ť.
- Do
ReplicatedStorage.Remotesvložte RemoteFunction s názvomRedeemCode. - Do StarterGui vložte ScreenGui s názvom
CodeGuia doň TextBox s názvomCodeBox. Veľkosť a umiestnenie vyberte podľa seba. - Pridajte Script nižšie do ServerScriptService a LocalScript dovnútra
CodeBox.
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.
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,
InvokeClientvyhodí 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.
| Kontrola | Otázka, ktorú si server kladie | Príklad |
|---|---|---|
| Typ | Je to typ, ktorý čakám? Instance, a nie tabuľka poskladaná tak, aby sa naň podobala? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Rozsah | Je číslo konečné a v povolených medziach? Má text rozumnú dĺžku? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Vlastníctvo | Vlastní 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 |
| Frekvencia | Neposiela 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.
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:
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ú:
| Pošlete | Čo sa stane |
|---|---|
| Funkciu | Druhá strana dostane nil |
| Tabuľku s metatabuľkou | Metatabuľ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ľúče | Roblox radí to nerobiť: posielajte čisté pole alebo čistý slovník |
Tabuľku s hodnotami nil vnútri | Vyhnite sa tomu: Roblox neodporúča nil na žiadnom indexe |
| Tabuľku s kľúčmi typu Instance, userdata alebo function | Takéto kľúče sa zmenia na reťazce |
| Instance, ktorý príjemca nevidí, napríklad zo ServerStorage alebo vytvorený v LocalScript | Druhá strana dostane nil |
| Akúkoľvek tabuľku | Prí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í:
- Cesta bez návratovej hodnoty. Každý výstup z
OnServerInvokemusí niečo vracať. Prázdnyreturnv skorej kontrole pošle späťnil. - return vnútri vnorenej funkcie.
returnvnútripcall(function() ... end), handlera:Connectalebotask.spawnvyskočí len z tejto vnútornej funkcie. Uložte výsledok, napríkladlocal ok, data = pcall(...), a potom vráťtedatazo samotného callbacku. - 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. - 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.waitaleboWaitForChild, ď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?
| Použite | Na čo | Príklad | Na čo si dať pozor |
|---|---|---|---|
| RemoteEvent | Sprá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 InvokeServer | Klient potrebuje odpoveď, skôr než môže pokračovať | Zadať promo kód, potvrdiť nákup | Volajúci čaká; každá cesta musí vracať hodnotu |
RemoteFunction s InvokeClient | Takmer nikdy | Namiesto toho použite FireClient | Klient, 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é efekty | Správy sa strácajú alebo menia poradie; limit dát 1000 bajtov |
| Atribút alebo value objekt nastavený serverom | Spoloč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 |
| BindableEvent | Komunikácia skriptov na tej istej strane | Jeden serverový skript oznámi druhému, že kolo skončilo | Neprechá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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (po anglicky). FireServer, FireClient, InvokeServer, riziká InvokeClient, obmedzenia argumentov a záruky doručenia
- Roblox Creator Docs: Securing the client-server boundary (po anglicky). Úrovne kontroly, NaN, limity frekvencie, preposielanie od klienta ku klientovi
- Roblox Creator Docs: Security and cheat mitigation tactics (po anglicky). Čo dokáže upravený klient a autorita servera
- Roblox Creator Docs: Network ownership, movement validation, and physics (po anglicky). Prečo klient ovláda svoju postavu a hranice kontrol vzdialenosti
- Roblox Engine API: RemoteEvent (po anglicky). Limit frekvencie a chyba invocation discarded
- Roblox Engine API: RemoteFunction (po anglicky). OnServerInvoke, varovania k InvokeClient a opatrenia pri streamingu
- Roblox Engine API: UnreliableRemoteEvent (po anglicky). Limit dát 1000 bajtov
- Roblox Creator Docs: Properties and attributes (po anglicky). Poradie replikácie medzi zmenami vlastností a remote events
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.