Pe scurt
Un RemoteEvent e un obiect care stă de obicei în ReplicatedStorage și transmite mesaje peste granița dintre client și server. Un LocalScript apelează FireServer, iar serverul primește mesajul în OnServerEvent, unde ca prim argument e adăugat Player-ul care l-a trimis. Serverul apelează FireClient(player, ...) sau FireAllClients(...), iar LocalScript-urile primesc mesajul în OnClientEvent.
- Folosește o RemoteFunction (
InvokeServerșiOnServerInvoke) doar când clientul are nevoie de un răspuns. EvităInvokeClient: un client care a avut o eroare, a ieșit sau nu a returnat niciodată o valoare strică apelul pe server. - Nu avea niciodată încredere în ce trimite clientul. Pe server verifică tipul, intervalul și proprietatea fiecărui argument, distanța până la jucător și cât de des declanșează remote-ul.
- Funcțiile, metatabelele și obiectele pe care cealaltă parte nu le vede nu supraviețuiesc transmiterii. Un UnreliableRemoteEvent poate pierde mesaje sau le poate schimba ordinea și aruncă orice date mai mari de 1000 de octeți.
Pe această pagină
De ce ai nevoie de RemoteEvent-uri
Orice joc Roblox funcționează ca un server plus câte un client pentru fiecare jucător. Serverul e cel principal: un obiect nou sau o schimbare de proprietate ajunge la toți jucătorii doar când o face serverul. O schimbare făcută într-un LocalScript rămâne pe un singur dispozitiv, cu puține excepții, precum propriul personaj al jucătorului, a cărui mișcare e controlată de clientul lui. De aceea, când un clic sau o apăsare de tastă trebuie să schimbe lumea comună, clientul trebuie să-i ceară serverului, iar când serverul vrea ca ecranul unui jucător să reacționeze, trebuie să-i spună clientului. Dacă împărțirea în Script și LocalScript e nouă pentru tine, citește întâi Script vs LocalScript vs ModuleScript (în engleză). Dacă e nou chiar scriptingul, începe cu cum scrii scripturi în Roblox Studio.
Pentru trecerea acestei granițe, Roblox oferă trei obiecte:
- RemoteEvent: un mesaj într-o singură direcție. Expeditorul își continuă imediat lucrul.
- RemoteFunction: o cerere care așteaptă un răspuns. Codul care a apelat stă pe pauză până când cealaltă parte returnează o valoare.
- UnreliableRemoteEvent: un mesaj într-o singură direcție care se poate pierde sau poate ajunge în altă ordine, dar încarcă mai puțin rețeaua. Potrivit pentru date care se schimbă tot timpul.
| Direcție | Expeditorul apelează | Destinatarul se conectează la | Destinatarul primește |
|---|---|---|---|
| De la client la server | remote:FireServer(...) într-un LocalScript | remote.OnServerEvent într-un Script | Player-ul care a trimis mesajul, apoi argumentele tale |
| De la server la un client | remote:FireClient(player, ...) într-un Script | remote.OnClientEvent într-un LocalScript | Doar argumentele tale |
| De la server la toți clienții | remote:FireAllClients(...) într-un Script | remote.OnClientEvent într-un LocalScript | Doar argumentele tale |
| Clientul întreabă, serverul răspunde | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player, apoi argumentele tale. Cel care a apelat primește ce a returnat funcția |
Clienții nu își pot trimite mesaje direct unul altuia. Ca să transmiți ceva de la un jucător celorlalți, trimite-l la server, verifică-l acolo și lasă serverul să-l retransmită prin FireClient sau FireAllClients. După recomandările de securitate Roblox, serverul lucrează aici ca un portar, nu ca un simplu releu.
Unde ții remote-urile
Un remote trebuie să stea acolo unde îl văd și serverul, și clienții. Locul obișnuit e ReplicatedStorage; documentația Roblox notează că în unele cazuri merg și Workspace sau un Tool. ServerStorage și ServerScriptService sunt accesibile doar serverului, așa că un LocalScript care așteaptă un remote de acolo va aștepta la nesfârșit.
- În Explorer treci cu mouse-ul peste ReplicatedStorage, apasă butonul + și inserează un Folder. Numește folderul
Remotes. - Treci cu mouse-ul peste
Remotes, apasă + și inserează un RemoteEvent. Redenumește-l astfel încât numele să descrie scopul, de exempluPaintRequest. - Repetă pentru fiecare remote. În acest ghid se folosesc două RemoteEvent-uri (
PaintRequestșiNotify) și o 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
Scripturile din acest ghid găsesc remote-urile prin WaitForChild. Acesta returnează rezultatul imediat dacă remote-ul e deja la locul lui și așteaptă dacă încă nu e, de exemplu când un script de server creează remote-urile în timpul jocului. Fă câte un remote separat pentru fiecare tip de cerere: atunci fiecare handler de server verifică o singură formă de argumente, iar asta e mult mai ușor de făcut corect decât cu un singur remote pentru toate cazurile.
Schema 1: de la client la server, cu verificare pe server
Cea mai frecventă sarcină: jucătorul face ceva pe ecranul lui, iar serverul decide ce se întâmplă. Aici jucătorul apasă Q ca să aleagă una din patru culori și dă clic sau atinge un part ca să-l vopsească. Noua culoare o văd toți, pentru că vopsește serverul.
Clientul trimite două lucruri: ce part și numărul culorii. Culoarea însăși nu o trimite niciodată, iar în alte jocuri la fel nu trebuie să trimită un preț, o recompensă sau mărimea daunelor. Un client modificat poate trimite orice, așa că datele reale (aici paleta) le ține serverul, iar argumentele le tratează ca pe o cerere care trebuie verificată.
- În Workspace inserează un Folder numit
Paintableși pune în el câteva Part-uri ancorate. - Verifică dacă în
ReplicatedStorage.Remotesexistă un RemoteEvent numitPaintRequest. - Inserează un Script numit
PaintServerîn ServerScriptService și un LocalScript numitPaintClientîn StarterPlayer, StarterPlayerScripts, cu codul de mai jos.
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")
-- Culorile aparțin serverului. Clientul trimite doar un număr care o alege pe una dintre ele.
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 -- studs între personaj și part
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- Primul parametru e mereu jucătorul care a declanșat remote-ul. Îl pune Roblox,
-- așa că poți avea încredere în el. Tot ce vine după el a venit de la client și nu e de încredere.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Tipul: un part adevărat, nu un tabel care se dă drept part
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Intervalul: un întreg de la 1 la 4. NaN și infinitul sunt și ele eliminate aici.
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. Ținta permisă: doar part-urile din folderul Paintable, nimic altceva din joc
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Distanța: personajul jucătorului trebuie să fie lângă part
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. Limita de frecvență: o vopsire pe jucător la fiecare sfert de secundă
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)
Fiecare verificare care nu trece face pur și simplu return. N-are rost să-i explici unui client trișor de ce a fost refuzat.
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 -- culorile reale le ține serverul
local selectedColour = 1
-- Raza poate lovi doar part-uri din folderul 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 -- tasta sau clicul au mers în chat sau pe un buton
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
-- Cerem, nu ordonăm: dacă vopsim sau nu decide serverul
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed e true când motorul a tratat deja acest input, de obicei în interfață: un clic pe un buton sau taste scrise într-un câmp de text precum linia de chat. Datorită acestei verificări, litera Q scrisă într-un mesaj nu schimbă culoarea.
Schema 2: de la server la un client
Serverul trimite un mesaj unui singur jucător prin FireClient. Primul argument e Player-ul căruia îi e adresat, iar handler-ul de pe client primește doar argumentele de după el. Folosește asta pentru tot ce e personal: o notificare, o fereastră cu recompensă, un sunet pe care trebuie să-l audă doar acel jucător. Ghidul despre cutscene-uri e un exemplu mai mare explicat: serverul decide când vede jucătorul cutscene-ul și îi trimite cadrele doar acelui jucător prin FireClient, iar camera o mișcă dispozitivul lui.
Această pereche de scripturi arată un salut când intră un jucător. LocalScript-ul își construiește singur un mic banner, așa că nu trebuie configurat niciun GUI.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local function welcome(player: Player)
-- Primul argument alege ce client primește mesajul. Nimeni altcineva nu-l va vedea.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- În Studio poți intra înainte să se conecteze acest script, așa că îi salutăm pe toți cei deja aici
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
-- Un mic banner în partea de sus a ecranului, construit în cod
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
-- Aici nu există parametrul player: serverul a ales deja cine primește mesajul
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 -- îl ascundem dacă nu l-a înlocuit un mesaj mai nou
label.Visible = false
end
end)
end)
Serverul trimite mesajul la PlayerAdded, iar asta se poate întâmpla înainte ca acest LocalScript să-și conecteze handler-ul. E în regulă: Roblox pune la coadă mesajele RemoteEvent sosite înainte de apariția handler-ului și le livrează în ordine imediat ce handler-ul se conectează.
Clientul nu trebuie să se apere de server: OnClientEvent îl poate declanșa doar cod de server. Adnotarea message: string e pentru verificarea de tipuri; nu e o verificare la rulare.
Schema 3: de la server la toți clienții
FireAllClients trimite același mesaj fiecărui jucător conectat. Nu are argumentul Player, iar fiecare client primește mesajul în același OnClientEvent ca înainte, așa că scriptul NotifyClient din schema 2 îl afișează deja.
Acest Script le anunță tuturor când un jucător atinge pentru prima dată linia de sosire. Adaugă în Workspace un Part ancorat numit FinishLine, apoi adaugă Script-ul în 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 -- nu e jucător sau a fost deja anunțat
end
finished[player] = true
-- Fiecare client conectat își rulează handler-ul OnClientEvent cu acest text
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
Un exploiter poate declanșa Touched pentru propriul personaj de la orice distanță, dar pentru un anunț arătat o dată pe jucător e inofensiv. Dacă mai târziu dai o recompensă pentru sosire, adaugă verificări pe server înainte de a o da, de exemplu un timp minim de la începutul rundei.
FireAllClients ajunge doar la jucătorii conectați în acel moment. Cine intră cu o secundă mai târziu nu mai vede mesajul. E potrivit pentru momente unice, precum un anunț, efectul unei explozii sau un sunet, dar nu și pentru o stare precum cronometrul rundei sau faza curentă a jocului. Pentru stare setează pe server un atribut, de exemplu ReplicatedStorage:SetAttribute("TimeLeft", 30), și citește-l pe client prin GetAttribute și GetAttributeChangedSignal("TimeLeft"). Atributele se replică la fiecare client, inclusiv la jucătorii intrați mai târziu.
RemoteFunction: când clientul are nevoie de un răspuns
Un RemoteEvent funcționează pe principiul „trimite și uită”. O RemoteFunction îl face pe cel care apelează să aștepte: InvokeServer pune pe pauză codul care l-a apelat până când funcția de server OnServerInvoke returnează o valoare, apoi dă ce a returnat ea. Folosește-o când clientul nu poate continua fără răspuns, de exemplu „a fost corect acest cod?”. Când nu e nevoie de răspuns, Roblox recomandă un RemoteEvent, pentru că nu așteaptă.
Exemplu: un câmp în care jucătorii introduc un cod promoțional. Serverul ține codurile, verifică textul și returnează două valori: dacă a mers și mesajul de afișat.
- În
ReplicatedStorage.Remotesinserează o RemoteFunction numităRedeemCode. - În StarterGui inserează un ScreenGui numit
CodeGui, iar în el un TextBox numitCodeBox. Mărimea și locul le alegi după gust. - Adaugă Script-ul de mai jos în ServerScriptService, iar LocalScript-ul în
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Codurile trăiesc pe server, unde niciun jucător nu le poate citi
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 } = {}
-- Atribuim cu =. OnServerInvoke e un callback, nu un eveniment la care faci 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)
Adaugă la statistica Coins din ghidul despre clasament. Codurile folosite se țin minte doar până iese jucătorul, așa că în forma asta jucătorul poate reintra și introduce același cod din nou. Dacă monedele se salvează, înseamnă monede gratuite la fiecare reintrare: înainte să folosești asta într-un joc live, păstrează codurile folosite de fiecare jucător împreună cu datele lui salvate, într-un depozit de date.
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 pune această funcție pe pauză până când callback-ul serverului returnează o valoare.
-- pcall împiedică oprirea LocalScript-ului dacă apelul a eșuat.
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)
O RemoteFunction are exact un callback de server. Dacă două scripturi setează OnServerInvoke la aceeași RemoteFunction, funcționează doar ultimul.
De ce e periculos InvokeClient
O RemoteFunction funcționează și în sens invers, cu InvokeClient pe server și OnClientInvoke pe client. Documentația Roblox enumeră trei riscuri serioase:
- Dacă callback-ul clientului dă eroare, dă eroare și serverul.
- Dacă jucătorul iese în timpul apelului,
InvokeClientdă eroare. - Dacă clientul nu returnează niciodată o valoare, scriptul de server va aștepta la nesfârșit.
Un client modificat își controlează callback-ul, așa că un trișor poate provoca intenționat al treilea caz și poate ține acel fir de server cât vrea. Ca să actualizezi ecranul unui jucător, folosește FireClient. Dacă serverul chiar are nevoie de o informație de la client, trimite un RemoteEvent, lasă clientul să răspundă prin alt RemoteEvent, iar lipsa răspunsului tratează-o pe server ca pe un caz obișnuit.
Verifică fiecare argument pe server
Un exploiter poate declanșa orice RemoteEvent sau orice RemoteFunction de câte ori vrea și cu orice argumente. Singurul lucru pe care nu-l poate falsifica e primul parametru: Roblox pune singur Player-ul care a trimis mesajul. Tot ce vine după trebuie verificat înainte ca serverul să acționeze. Să ascunzi remote-ul sau să verifici într-un LocalScript nu folosește la nimic, pentru că trișorul își controlează clientul.
| Verificare | Întrebarea pe care și-o pune serverul | Exemplu |
|---|---|---|
| Tipul | E tipul pe care îl aștept? Un Instance, nu un tabel construit să semene cu el? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Intervalul | Numărul e finit și în limitele permise? Textul are o lungime rezonabilă? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Proprietatea | Jucătorul deține obiectul, are destui bani, are dreptul să acționeze asupra acestui obiect? | Obiectul e în inventarul lui; part-ul stă în Paintable |
| Distanța | E personajul jucătorului destul de aproape în copia lumii de pe server? Lasă o mică rezervă pentru lag. | La cel mult 30 de studs de part |
| Frecvența | Nu trimite acest jucător prea des? | Un cooldown pe jucător sau o limită cu acumulare de apeluri |
NaN merită un avertisment separat. E un număr, așa că type(x) == "number" trece, dar orice comparație cu el dă false, iar o verificare precum x < 0 or x > 100 îl lasă să treacă. math.isfinite(x) respinge NaN și ambele infinituri.
Ține minte limita verificării distanței. Fiecare client controlează fizica propriului personaj, așa că un exploiter își poate muta personajul lângă țintă înainte de apel. Verificarea tot oprește cel mai simplu abuz, când acționezi de pe loc asupra întregii hărți. Ține part-urile-țintă ancorate: documentația de securitate Roblox notează că un exploiter poate obține proprietatea de rețea asupra part-urilor neancorate din jurul lui și le poate trage mai aproape, iar asta ocolește verificarea distanței.
Iată aceleași verificări sub forma unui ModuleScript pe care îl poți folosi în fiecare handler de remote.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Un număr real între min și max. Respinge NaN și infinitul, care trec
-- de verificarea obișnuită 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
-- Un întreg între min și max, pentru cantități, indecși și contoare
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 cu lungime limitată. utf8.len returnează nil pentru UTF-8 invalid, pe care
-- depozitele de date îl resping.
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
-- Un Instance din clasa așteptată, într-un container pe care l-ai permis.
-- Un tabel construit să semene cu un Instance nu trece de verificarea typeof.
function RemoteGuard.instanceIn(value: unknown, className: string, container: Instance): Instance?
if typeof(value) ~= "Instance" then
return nil
end
if not value:IsA(className) or not value:IsDescendantOf(container) then
return nil
end
return value
end
-- True când personajul jucătorului e la cel mult maxDistance studs de 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ă de frecvență pe jucător. Fiecare jucător poate face `burst` apeluri deodată și
-- primește înapoi `perSecond` apeluri în fiecare secundă. Returnează o funcție pe care o apelezi
-- înainte de lucru: răspunde true (se poate) sau false (prea des).
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
Ține-l în ServerScriptService. Codul de acolo nu ajunge niciodată la clienți, așa că nimeni nu-ți va citi verificările.
Iar acesta e handler-ul din schema 1, rescris cu ajutorul lui. Înlocuiește conținutul lui PaintServer:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" contează doar pentru verificarea strictă de tipuri Luau; la rulare nu schimbă nimic
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) -- un lot de 4, apoi 4 pe secundă
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)
Limitatorul șterge intrarea jucătorului când acesta iese, așa că tabelul lui nu crește pe toată durata de viață a serverului.
La arme aceste verificări contează cel mai mult: nu lăsa niciodată clientul să spună pe cine a lovit. Remote-ul din ghidul despre sabie nu poartă deloc argumente, iar serverul găsește singur țintele. Ghidul despre arme trimite doar punctul de țintire, pe care serverul îl verifică la tip, NaN și distanță înainte să tragă propria rază.
Meniurile respectă aceeași regulă: trimite alegerea, nu rezultatul. În ghidul despre dialogurile cu NPC clientul trimite doar numărul butonului apăsat, iar serverul se uită singur ce dă acel răspuns. Meniul din ghidul despre teleporturi trimite numele punctului, nu poziția, iar serverul găsește punctul în folderul lui și verifică de câte Wins e nevoie pentru el.
Ce poți și ce nu poți trimite
Poți transmite numere, șiruri, valori booleene, tipuri Roblox precum Vector3, CFrame, Color3 și elemente Enum, Instance-uri pe care le văd ambele părți și tabele din toate acestea. Unele valori se schimbă sau dispar pe drum:
| Trimiți | Ce se întâmplă |
|---|---|
| O funcție | Cealaltă parte primește nil |
| Un tabel cu metatabel | Metatabelul se pierde, împreună cu tot ce avea tabelul doar prin el |
| Un tabel în care sunt amestecate chei numerice și chei text | Roblox recomandă să nu faci asta: trimite o listă curată sau un dicționar curat |
Un tabel cu valori nil în interior | Evită: Roblox nu recomandă nil la niciun index |
| Un tabel cu chei de tip Instance, userdata sau function | Astfel de chei devin șiruri |
| Un Instance pe care destinatarul nu-l vede, de exemplu din ServerStorage sau creat într-un LocalScript | Cealaltă parte primește nil |
| Orice tabel | Destinatarul primește o copie, nu același tabel |
Un obicei bun: trimite identificatori, nu obiecte sau valori. Numele unui obiect, numărul unei variante, un part pe care serverul îl poate găsi și verifica. Mai departe serverul lucrează cu propriile date.
De ce returnează o RemoteFunction nil
Dacă InvokeServer îți dă nil, parcurge aceste puncte în ordine:
- O ramură fără valoare returnată. Fiecare ieșire din
OnServerInvoketrebuie să returneze ceva. Unreturngol într-o verificare timpurie trimite înapoinil. - return într-o funcție imbricată. Un
returndintr-unpcall(function() ... end), dintr-un handler:Connectsau dintr-untask.spawniese doar din acea funcție interioară. Salvează rezultatul, de exemplulocal ok, data = pcall(...), apoi returneazădatadin callback-ul însuși. - O valoare care nu poate trece granița. O funcție sau un Instance pe care clientul nu-l vede (de exemplu, orice din ServerStorage) ajunge ca
nil. Cu instance streaming activ, un part pe care serverul tocmai l-a creat poate să nu fi ajuns încă la client în momentul în care funcția returnează. - Callback-ul l-a setat alt script. Funcționează doar ultima atribuire a
OnServerInvoke. Caută numele remote-ului prin scripturile tale.
Dacă apelul nu se întoarce deloc, înseamnă că niciun script nu a setat încă OnServerInvoke (Roblox ține apelurile la coadă până se setează) sau callback-ul s-a blocat, de exemplu pe un WaitForChild pentru ceva ce nu apare niciodată.
UnreliableRemoteEvent: pentru actualizări constante, de unică folosință
Un UnreliableRemoteEvent are aceleași metode și evenimente ca un RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent și OnClientEvent. Diferența e că Roblox nu garantează nici livrarea, nici ordinea. Un mesaj poate fi aruncat fără retrimitere când:
- se pierde pe drum sau așteaptă prea mult într-o rețea aglomerată
- datele lui depășesc 1000 de octeți
- clientul trimite mai des decât limita (surplusul e aruncat, nu amânat)
- în momentul sosirii nu e conectat niciun handler (e aruncat, nu pus la coadă)
Mesajele pot ajunge și în altă ordine, iar ordinea lor nu are nicio legătură cu RemoteEvent-urile sau RemoteFunction-urile tale. Folosește-l când contează doar cea mai recentă valoare, iar următoarea actualizare vine într-o fracțiune de secundă: unde țintește jucătorul, poziția unui efect cosmetic, o valoare care se schimbă la fiecare cadru. Dacă ordinea contează, pune în fiecare mesaj un număr de ordine sau un moment de timp și ignoră tot ce e mai vechi decât ultimul tratat.
Nu-l folosi niciodată pentru ceva ce trebuie să se întâmple exact o dată, de exemplu o cumpărare, daune, o recompensă sau începutul unei runde. Și verifică-i argumentele pe server exact ca la un RemoteEvent.
Ordinea de livrare și limitele de frecvență
Garanțiile de livrare Roblox se referă la o conexiune într-o direcție: de la server la un client sau de la un client la server.
- RemoteEvent-urile sunt fiabile și ordonate. Mesajele pierdute se retrimit cât timp destinatarul rămâne conectat, iar mesajele ajung în ordinea în care le-ai trimis, chiar și prin RemoteEvent-uri diferite. Dacă serverul îi trimite unui jucător A, apoi B, apoi A, acel jucător primește A, B, A.
- Ordinea se referă la momentul pornirii handler-elor. Dacă un handler cedează controlul, de exemplu prin
task.waitsauWaitForChild, următorul mesaj poate începe să fie tratat înainte să se termine primul. - RemoteFunction-urile și RemoteEvent-urile nu sunt ordonate unele față de altele. Dacă codul tău depinde de o ordine strictă, trimite mesajele legate prin același tip de remote sau adaugă propriul număr de ordine.
- Schimbările de proprietăți și atribute nu sunt ordonate față de remote-uri. Dacă serverul schimbă o proprietate și apoi declanșează un remote, clientul poate vedea întâi oricare dintre ele. Ascultă schimbarea însăși, de exemplu prin
GetPropertyChangedSignal, nu te baza că a ajuns deja. - Handler-ul nu există încă. Mesajele RemoteEvent stau la coadă până se conectează un handler. Coada are limite: când e plină, mesajele următoare sunt aruncate, iar în Output apare eroarea
Remote event invocation discarded. - Un jucător care iese pierde toate mesajele care nu au ajuns încă la el.
Limita de frecvență. Mesajele RemoteEvent și UnreliableRemoteEvent de la client la server sunt limitate la aproximativ 500 de cereri pe secundă pe client, conform documentației la 30 septembrie 2026. Limita e comună pentru toate remote-urile de același tip, așa că împărțirea unui remote aglomerat în zece nu o ridică. Peste limită, mesajele RemoteEvent sunt tratate mai târziu și își păstrează ordinea, iar mesajele UnreliableRemoteEvent sunt aruncate. Limita motorului nu împiedică deloc un jucător să-ți declanșeze remote-ul de 50 de ori pe secundă, așa că fiecare handler care schimbă ceva are nevoie în continuare de propria limită pe jucător.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent sau atribut?
| Folosește | Pentru ce | Exemplu | La ce să fii atent |
|---|---|---|---|
| RemoteEvent | Mesaje într-o direcție care trebuie să ajungă, și în ordine | Clientul: „vopsește acest part”. Serverul: „arată această notificare” | Verifică fiecare argument pe server |
RemoteFunction cu InvokeServer | Clientul are nevoie de un răspuns înainte să poată continua | Introducerea unui cod promoțional, confirmarea unei cumpărări | Cel care apelează așteaptă; fiecare ramură trebuie să returneze o valoare |
RemoteFunction cu InvokeClient | Aproape niciodată | Folosește în schimb FireClient | Un client care are o eroare, a ieșit sau nu a răspuns strică sau blochează apelul pe server |
| UnreliableRemoteEvent | Actualizări dese, unde contează doar ultima | Direcția de țintire, efecte cosmetice | Mesajele se pierd sau își schimbă ordinea; limita de date e 1000 de octeți |
| Un atribut sau un value-object setat de server | O stare comună care trebuie să se vadă mereu, inclusiv de jucătorii intrați mai târziu | Cronometrul rundei, faza jocului, dacă o ușă e deschisă | La toți ajung doar schimbările serverului; clienții ascultă prin GetAttributeChangedSignal sau Changed |
| BindableEvent | Comunicarea scripturilor de pe aceeași parte | Un script de server îi spune altuia că runda s-a terminat | Nu trece între server și client |
Un exemplu complet despre cum lucrează împreună RemoteFunction și verificările acolo unde jucătorii plătesc vezi în ghidul cum faci un GUI de magazin. Cât despre rândul cu atributele, scriptul de server din ghidul despre uși setează atributul Open pe fiecare ușă la fiecare mișcare a ei, așa că orice LocalScript poate reacționa la el.
Erori frecvente și soluții
Cele mai multe probleme cu remote-urile se văd în fereastra Output (o deschizi din meniul Window sau din fila Script). Uită-te întâi acolo, apoi găsește-ți simptomul mai jos. Ghidul despre erorile din scripturi explică mai pe larg mesajele de eroare generale.
Infinite yield possible la WaitForChild pentru un remote
Scriptul așteaptă un remote care nu va apărea niciodată. Verifică dacă numele și majusculele se potrivesc exact și dacă remote-ul stă în ReplicatedStorage, nu în ServerStorage sau ServerScriptService, pe care clienții nu le văd.
Serverul primește valorile greșite, decalate cu una
LocalScript-ul a transmis jucătorul însuși, ca în remote:FireServer(player, 5). Roblox adaugă oricum expeditorul ca prim parametru, așa că serverul vede (player, player, 5). Apelează remote:FireServer(5).
Nu se întâmplă nimic când declanșez remote-ul
Verifică dacă fiecare apel vine din partea potrivită: FireServer și InvokeServer merg doar din cod de client, iar FireClient, FireAllClients și InvokeClient doar dintr-un Script de server. Un LocalScript nu rulează niciodată în ServerScriptService, ServerStorage sau direct în Workspace; pune-l în StarterPlayerScripts, StarterGui, StarterCharacterScripts sau StarterPack. Apoi caută în Output o eroare din handler.
Remote event invocation discarded
Au sosit mesaje pentru un RemoteEvent care nu avea niciun handler conectat, iar coada s-a umplut. De obicei scriptul cu handler-ul cade cu o eroare înainte de rândul cu :Connect, e dezactivat sau s-a blocat așteptând ceva ce nu se încarcă niciodată. Conectează handler-ele aproape de începutul scriptului.
La mine merge, dar ceilalți jucători nu văd schimbarea
Schimbarea e făcută pe client, într-un LocalScript sau într-un handler OnClientEvent. Fă-o în handler-ul de server OnServerEvent.
InvokeServer nu se întoarce niciodată
Fie niciun script nu a setat OnServerInvoke (Roblox ține apelurile la coadă până se setează), fie callback-ul s-a blocat pe ceva ce cedează controlul, de exemplu pe WaitForChild sau pe o cerere la un depozit de date. Adaugă un print la începutul și la sfârșitul callback-ului ca să vezi unde se oprește.
Fă-o cu RoCode
Asta o poate configura și RoCode, direct în place-ul pe care îl ai deschis. RoCode este un agent AI care lucrează printr-un plugin pentru Roblox Studio, așa că creează remote-urile și scripturile în Explorer-ul tău, în loc să-ți dea cod de lipit.
Lasă jucătorii să vopsească part-urile din folderul Paintable cu un clic. Folosește un RemoteEvent și păstrează verificările pe server: doar part-urile din acest folder, la cel mult 30 de studs și nu mai mult de câteva vopsiri pe secundă.
- De obicei se uită întâi prin place cu Search Game și Search Scripts după un folder Remotes sau un handler existent și îți folosește folderele, dacă există
- Creează RemoteEvent-ul în ReplicatedStorage prin Create Instance și scrie Script-ul de server și LocalScript-ul prin Create Script
- Înainte să termine, verifică în Studio compilarea fiecărui script prin Check Script. Asta prinde erorile de compilare, nu greșelile de logică: nu verifică tipurile, nu rulează un linter și nu îți execută codul
- Trimite modificările în loturi, iar fiecare lot e un punct de anulare în istoria Studio
Cu pluginul 3.9 sau mai nou, RoCode poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.11 sau mai nou poate controla un personaj de test, dar nu dă clic pe part-uri în fereastra 3D. Apasă singur Play și încearcă să strici verificările, de exemplu vopsind un part de la celălalt capăt al hărții. Dacă apare o eroare, Check Output poate citi rândurile Server și Client din ultimul tău playtest. Cele mai multe sisteme de joc comunică prin astfel de remote-uri, așa că le vei întâlni din nou când vei construi un joc sistem cu sistem cu RoCode. Cum se conectează RoCode la Studio.
Întrebări frecvente
Ce înseamnă securing the client-server boundary în Roblox?
Așa se numește pagina din documentația Roblox despre securitatea remote-urilor, iar ideea e simplă: tot ce trimite clientul printr-un RemoteEvent sau o RemoteFunction poate veni de la un exploiter, așa că serverul verifică înainte să acționeze. Verifică tipul fiecărui argument, ține numerele în limite rezonabile, verifică dacă jucătorului îi e permis acum să facă asta și limitează cât de des poate declanșa fiecare jucător remote-ul. Lista de verificări de mai sus arată fiecare dintre ele în cod.
E sigur să folosești RemoteFunction?
InvokeServer e atât de sigur cât e de sigur callback-ul tău de server: verifică-i argumentele și limitează frecvența, ca la orice RemoteEvent. Direcția riscantă e InvokeClient, pentru că un client care are o eroare, a ieșit sau nu a returnat niciodată o valoare strică sau blochează apelul pe server.
Pot exploiterii să-mi vadă și să-mi declanșeze remote-urile?
Da. Tot ce stă în ReplicatedStorage ajunge la fiecare client, iar un client modificat poate declanșa orice remote cu orice argumente. Redenumirea sau ascunderea remote-urilor nu le face sigure; sigure le face verificarea fiecărui argument pe server.
Poate un client să trimită un RemoteEvent altui client?
Direct, nu. Trimite-l la server, verifică-l acolo, apoi folosește FireClient sau FireAllClients.
Cât de des poți declanșa un RemoteEvent?
Documentația Roblox indică o limită de aproximativ 500 de cereri pe secundă pe client pentru mesajele RemoteEvent și UnreliableRemoteEvent trimise la server, comună pentru toate remote-urile de același tip. Stai mult sub ea și dă-i fiecărui handler propria limită pe jucător.
Ajunge FireAllClients la jucătorii intrați mai târziu?
Nu. Ajunge la jucătorii conectați în acel moment. Pentru o stare de care au nevoie cei întârziați, setează pe server un atribut sau un value-object.
Care e diferența dintre RemoteEvent și BindableEvent?
Un RemoteEvent trece între server și client. Un BindableEvent leagă scripturi de pe aceeași parte, de exemplu două scripturi de server.
Surse și lecturi suplimentare
- Roblox Creator Docs: Remote events and callbacks (în engleză). FireServer, FireClient, InvokeServer, riscurile InvokeClient, limitările argumentelor și garanțiile de livrare
- Roblox Creator Docs: Securing the client-server boundary (în engleză). Niveluri de verificare, NaN, limite de frecvență, retransmiterea de la client la client
- Roblox Creator Docs: Security and cheat mitigation tactics (în engleză). Ce poate un client modificat și autoritatea serverului
- Roblox Creator Docs: Network ownership, movement validation, and physics (în engleză). De ce clientul își controlează personajul și limitele verificărilor de distanță
- Roblox Engine API: RemoteEvent (în engleză). Limita de frecvență și eroarea invocation discarded
- Roblox Engine API: RemoteFunction (în engleză). OnServerInvoke, avertismentele despre InvokeClient și precauțiile cu streaming
- Roblox Engine API: UnreliableRemoteEvent (în engleză). Limita de date de 1000 de octeți
- Roblox Creator Docs: Properties and attributes (în engleză). Ordinea replicării între schimbările de proprietăți și remote events
Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.