Tutorial · Bazele scriptingului

RemoteEvent în Roblox: de la client la server și înapoi

Un LocalScript nu poate schimba ce văd ceilalți jucători, iar un Script de server nu poate ajunge la ecranul unui singur jucător. Mesajele dintre ele le transmit RemoteEvent-urile. În acest ghid construim cele trei scheme de care vei avea nevoie cel mai des, o RemoteFunction care returnează un răspuns și verificările pe server care împiedică un client modificat să abuzeze de ele.

Actualizat 20 noiembrie 202619 min de cititAutor:

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 și OnServerInvoke) 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ă
  1. De ce remote-uri
  2. Configurarea remote-urilor
  3. 1. De la client la server
  4. 2. De la server la client
  5. 3. De la server la toți
  6. RemoteFunction
  7. Lista de verificări
  8. Ce nu poți trimite
  9. Returnează nil?
  10. UnreliableRemoteEvent
  11. Ordine și limite
  12. Ce să alegi
  13. Common errors
  14. Cu RoCode
  15. Întrebări frecvente
  16. Surse și lecturi suplimentare

De ce ai nevoie de RemoteEvent-uri

IlustrațieFiecare clic îi cere serverului să vopsească un part, așa că noua culoare se vede pe ecranele ambilor jucători.

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.
Ce apel declanșează ce eveniment
DirecțieExpeditorul apeleazăDestinatarul se conectează laDestinatarul primește
De la client la serverremote:FireServer(...) într-un LocalScriptremote.OnServerEvent într-un ScriptPlayer-ul care a trimis mesajul, apoi argumentele tale
De la server la un clientremote:FireClient(player, ...) într-un Scriptremote.OnClientEvent într-un LocalScriptDoar argumentele tale
De la server la toți cliențiiremote:FireAllClients(...) într-un Scriptremote.OnClientEvent într-un LocalScriptDoar argumentele tale
Clientul întreabă, serverul răspunderemoteFunction: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.

  1. În Explorer treci cu mouse-ul peste ReplicatedStorage, apasă butonul + și inserează un Folder. Numește folderul Remotes.
  2. Treci cu mouse-ul peste Remotes, apasă + și inserează un RemoteEvent. Redenumește-l astfel încât numele să descrie scopul, de exemplu PaintRequest.
  3. Repetă pentru fiecare remote. În acest ghid se folosesc două RemoteEvent-uri (PaintRequest și Notify) și o RemoteFunction (RedeemCode).
Explorer: tot ce adaugă acest ghid, secțiune cu secțiune
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ă.

  1. În Workspace inserează un Folder numit Paintable și pune în el câteva Part-uri ancorate.
  2. Verifică dacă în ReplicatedStorage.Remotes există un RemoteEvent numit PaintRequest.
  3. Inserează un Script numit PaintServer în ServerScriptService și un LocalScript numit PaintClient în StarterPlayer, StarterPlayerScripts, cu codul de mai jos.
Script în ServerScriptService cu numele 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")

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

LocalScript în StarterPlayerScripts cu numele 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 -- 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.

Script în ServerScriptService cu numele WelcomeServer
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
LocalScript în StarterPlayerScripts cu numele NotifyClient
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.

Script în ServerScriptService cu numele 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 -- 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.

  1. În ReplicatedStorage.Remotes inserează o RemoteFunction numită RedeemCode.
  2. În StarterGui inserează un ScreenGui numit CodeGui, iar în el un TextBox numit CodeBox. Mărimea și locul le alegi după gust.
  3. Adaugă Script-ul de mai jos în ServerScriptService, iar LocalScript-ul în CodeBox.
Script în ServerScriptService cu numele RedeemServer
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.

LocalScript în TextBox-ul CodeBox cu numele 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 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, InvokeClient dă 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.

Lista de verificări pentru server
VerificareÎntrebarea pe care și-o pune serverulExemplu
TipulE tipul pe care îl aștept? Un Instance, nu un tabel construit să semene cu el?typeof(part) == "Instance" and part:IsA("BasePart")
IntervalulNumărul e finit și în limitele permise? Textul are o lungime rezonabilă?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
ProprietateaJucă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țaE 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țaNu 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.

ModuleScript în ServerScriptService cu numele RemoteGuard
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:

Script în ServerScriptService cu numele 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:

Argumente care ajung altfel decât au fost trimise
TrimițiCe se întâmplă
O funcțieCealaltă parte primește nil
Un tabel cu metatabelMetatabelul se pierde, împreună cu tot ce avea tabelul doar prin el
Un tabel în care sunt amestecate chei numerice și chei textRoblox recomandă să nu faci asta: trimite o listă curată sau un dicționar curat
Un tabel cu valori nil în interiorEvită: Roblox nu recomandă nil la niciun index
Un tabel cu chei de tip Instance, userdata sau functionAstfel de chei devin șiruri
Un Instance pe care destinatarul nu-l vede, de exemplu din ServerStorage sau creat într-un LocalScriptCealaltă parte primește nil
Orice tabelDestinatarul 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:

  1. O ramură fără valoare returnată. Fiecare ieșire din OnServerInvoke trebuie să returneze ceva. Un return gol într-o verificare timpurie trimite înapoi nil.
  2. return într-o funcție imbricată. Un return dintr-un pcall(function() ... end), dintr-un handler :Connect sau dintr-un task.spawn iese doar din acea funcție interioară. Salvează rezultatul, de exemplu local ok, data = pcall(...), apoi returnează data din callback-ul însuși.
  3. 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ă.
  4. 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.wait sau WaitForChild, 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?

Cum alegi felul în care comunică clientul și serverul
FoloseștePentru ceExempluLa ce să fii atent
RemoteEventMesaje într-o direcție care trebuie să ajungă, și în ordineClientul: „vopsește acest part”. Serverul: „arată această notificare”Verifică fiecare argument pe server
RemoteFunction cu InvokeServerClientul are nevoie de un răspuns înainte să poată continuaIntroducerea unui cod promoțional, confirmarea unei cumpărăriCel care apelează așteaptă; fiecare ramură trebuie să returneze o valoare
RemoteFunction cu InvokeClientAproape niciodatăFolosește în schimb FireClientUn client care are o eroare, a ieșit sau nu a răspuns strică sau blochează apelul pe server
UnreliableRemoteEventActualizări dese, unde contează doar ultimaDirecția de țintire, efecte cosmeticeMesajele se pierd sau își schimbă ordinea; limita de date e 1000 de octeți
Un atribut sau un value-object setat de serverO stare comună care trebuie să se vadă mereu, inclusiv de jucătorii intrați mai târziuCronometrul rundei, faza jocului, dacă o ușă e deschisăLa toți ajung doar schimbările serverului; clienții ascultă prin GetAttributeChangedSignal sau Changed
BindableEventComunicarea scripturilor de pe aceeași parteUn script de server îi spune altuia că runda s-a terminatNu 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.

Tu scrii

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

RoCode face
  • 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

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.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.