Tutorial · Basi dello scripting

RemoteEvent su Roblox: dal client al server e ritorno

Un LocalScript non può cambiare quello che vedono gli altri giocatori, e uno Script sul server non può raggiungere lo schermo di un singolo giocatore. I messaggi tra i due li portano i RemoteEvent. In questa guida costruiamo i tre schemi che ti serviranno più spesso, una RemoteFunction che restituisce una risposta e i controlli sul server che impediscono a un client modificato di abusarne.

Aggiornato il 20 novembre 202620 min di letturaScritto da

In breve

Un RemoteEvent è un oggetto, di solito in ReplicatedStorage, che porta messaggi attraverso il confine tra client e server. Un LocalScript chiama FireServer e il server riceve il messaggio in OnServerEvent, con il Player che l'ha inviato aggiunto come primo argomento. Il server chiama FireClient(player, ...) o FireAllClients(...) e i LocalScript ricevono il messaggio in OnClientEvent.

  • Usa una RemoteFunction (InvokeServer e OnServerInvoke) solo quando il client ha bisogno di una risposta. Evita InvokeClient: un client che va in errore, esce o non restituisce mai un valore rompe la chiamata sul server.
  • Non fidarti mai di quello che invia il client. Sul server controlla tipo, intervallo e appartenenza di ogni argomento, la distanza del giocatore e quanto spesso chiama il remote.
  • Funzioni, metatabelle e oggetti che l'altra parte non vede non sopravvivono al viaggio. Un UnreliableRemoteEvent può perdere messaggi o cambiarne l'ordine e scarta qualsiasi dato oltre i 1000 byte.
In questa pagina
  1. A cosa servono i remote
  2. Preparare i remote
  3. 1. Dal client al server
  4. 2. Dal server al client
  5. 3. Dal server a tutti
  6. RemoteFunction
  7. Lista dei controlli
  8. Cosa non si può inviare
  9. Restituisce nil?
  10. UnreliableRemoteEvent
  11. Ordine e limiti
  12. Cosa scegliere
  13. Common errors
  14. Con RoCode
  15. Domande frequenti
  16. Fonti e letture

A cosa servono i RemoteEvent

IllustrazioneOgni clic chiede al server di colorare la parte, quindi il nuovo colore si vede sugli schermi di entrambi i giocatori.

Ogni gioco Roblox funziona come un server più un client per ogni giocatore. Qui comanda il server: un nuovo oggetto o il cambio di una proprietà arriva a tutti i giocatori solo quando lo fa il server. Un cambiamento fatto in un LocalScript resta su un solo dispositivo, con poche eccezioni come il personaggio del giocatore stesso, il cui movimento è gestito dal suo client. Per questo, quando un clic o un tasto devono cambiare il mondo condiviso, il client deve chiedere al server, e quando il server vuole che reagisca lo schermo di un solo giocatore, deve dirlo a quel client. Se la divisione tra Script e LocalScript ti è nuova, leggi prima Script vs LocalScript vs ModuleScript (in inglese). Se ti è nuovo lo scripting in sé, comincia da come programmare in Roblox Studio.

Per attraversare questo confine Roblox offre tre oggetti:

  • RemoteEvent: un messaggio in una sola direzione. Chi lo invia continua subito il suo lavoro.
  • RemoteFunction: una richiesta che aspetta una risposta. Il codice chiamante resta in pausa finché l'altra parte non restituisce un valore.
  • UnreliableRemoteEvent: un messaggio in una sola direzione che può perdersi o arrivare fuori ordine, ma pesa meno sulla rete. Va bene per dati che cambiano di continuo.
Quale chiamata fa scattare quale evento
DirezioneChi invia chiamaChi riceve si collega aChi riceve ottiene
Dal client al serverremote:FireServer(...) in un LocalScriptremote.OnServerEvent in uno ScriptIl Player che ha inviato il messaggio, poi i tuoi argomenti
Dal server a un clientremote:FireClient(player, ...) in uno Scriptremote.OnClientEvent in un LocalScriptSolo i tuoi argomenti
Dal server a tutti i clientremote:FireAllClients(...) in uno Scriptremote.OnClientEvent in un LocalScriptSolo i tuoi argomenti
Il client chiede, il server risponderemoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Il Player, poi i tuoi argomenti. Il chiamante riceve quello che la funzione ha restituito

I client non possono mandarsi messaggi direttamente. Per passare qualcosa da un giocatore agli altri, invialo al server, controllalo lì e lascia che sia il server a inoltrarlo con FireClient o FireAllClients. Secondo le raccomandazioni di sicurezza di Roblox, qui il server fa da guardiano, non da semplice ripetitore.

Dove tenere i remote

Un remote deve stare dove lo vedono sia il server sia i client. Il posto abituale è ReplicatedStorage; la documentazione di Roblox nota che in alcuni casi vanno bene anche Workspace o un Tool. ServerStorage e ServerScriptService sono accessibili solo al server, quindi un LocalScript che aspetta un remote da lì aspetterà per sempre.

  1. Nell'Explorer passa il mouse su ReplicatedStorage, clicca sul pulsante + e inserisci un Folder. Chiama la cartella Remotes.
  2. Passa il mouse su Remotes, clicca su + e inserisci un RemoteEvent. Rinominalo con un nome che ne descriva lo scopo, per esempio PaintRequest.
  3. Ripeti per ogni remote. Questa guida usa due RemoteEvent (PaintRequest e Notify) e una RemoteFunction (RedeemCode).
Explorer: tutto quello che aggiunge questa guida, sezione per sezione
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

Gli script di questa guida trovano i remote con WaitForChild. Restituisce subito il risultato se il remote c'è già, e aspetta se non c'è ancora, per esempio quando uno script del server crea i remote durante il gioco. Crea un remote separato per ogni tipo di richiesta: così ogni gestore sul server controlla una sola forma di argomenti, ed è molto più facile farlo bene che con un unico remote per tutto.

Schema 1: dal client al server, con controllo sul server

Il caso più comune: il giocatore fa qualcosa sul suo schermo e il server decide cosa succede. Qui il giocatore preme Q per scegliere uno di quattro colori e clicca o tocca una parte per colorarla. Il nuovo colore lo vedono tutti, perché a colorare è il server.

Il client invia due cose: quale parte e il numero del colore. Il colore in sé non lo invia mai, e allo stesso modo in altri giochi non deve inviare un prezzo, una ricompensa o la quantità di danno. Un client modificato può inviare qualsiasi cosa, quindi i dati veri (qui la tavolozza) li tiene il server, e gli argomenti li tratta come una richiesta da controllare.

  1. In Workspace inserisci un Folder chiamato Paintable e mettici dentro alcune Part ancorate.
  2. Controlla che in ReplicatedStorage.Remotes ci sia un RemoteEvent chiamato PaintRequest.
  3. Inserisci uno Script chiamato PaintServer in ServerScriptService e un LocalScript chiamato PaintClient in StarterPlayer, StarterPlayerScripts, con il codice qui sotto.
Script in ServerScriptService chiamato 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")

-- I colori appartengono al server. Il client invia solo il numero che ne sceglie uno.
local PALETTE = {
	Color3.fromRGB(231, 76, 60),
	Color3.fromRGB(46, 204, 113),
	Color3.fromRGB(52, 152, 219),
	Color3.fromRGB(241, 196, 15),
}
local MAX_DISTANCE = 30 -- stud tra il personaggio e la parte
local COOLDOWN_SECONDS = 0.25

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

-- Il primo parametro è sempre il giocatore che ha chiamato il remote. Lo inserisce Roblox,
-- quindi ci si può fidare. Tutto quello che viene dopo arriva dal client, e di quello non ci si può fidare.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Tipo: una parte vera, non una tabella che finge di esserlo
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Intervallo: un intero da 1 a 4. Anche NaN e infinito vengono scartati qui.
	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. Bersaglio consentito: solo le parti nella cartella Paintable, nient'altro nel gioco
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Distanza: il personaggio del giocatore deve essere vicino alla 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. Limite di frequenza: una colorazione per giocatore ogni quarto di secondo
	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)

Ogni controllo non superato fa semplicemente return. Non serve spiegare a un client che bara perché è stato respinto.

LocalScript in StarterPlayerScripts chiamato 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 -- i colori veri li tiene il server
local selectedColour = 1

-- Il raggio può colpire solo le parti dentro la cartella 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 -- il tasto o il clic sono andati alla chat o a un pulsante
	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
			-- Chiediamo, non ordiniamo: se colorare o no lo decide il server
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed è true quando il motore ha già gestito quell'input, di solito nell'interfaccia: un clic su un pulsante o tasti digitati in un campo di testo come la riga della chat. Grazie a questo controllo, la lettera Q scritta in un messaggio non cambia il colore.

Schema 2: dal server a un client

Il server invia un messaggio a un giocatore con FireClient. Il primo argomento è il Player a cui è destinato, e il gestore sul client riceve solo gli argomenti che vengono dopo. Usalo per tutto ciò che è personale: una notifica, una finestra con una ricompensa, un suono che deve sentire solo quel giocatore. La guida alle cutscene è un esempio più grande e spiegato passo per passo: il server decide quando il giocatore vedrà la cutscene e invia i suoi fotogrammi a quel solo giocatore con FireClient, mentre la telecamera la muove il suo dispositivo.

Questa coppia di script mostra un messaggio di benvenuto quando un giocatore entra. Il LocalScript costruisce da solo un piccolo banner, quindi non serve preparare una GUI.

Script in ServerScriptService chiamato WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

local function welcome(player: Player)
	-- Il primo argomento sceglie quale client riceve il messaggio. Nessun altro lo vedrà.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- In Studio puoi entrare prima che questo script si colleghi, quindi diamo il benvenuto a chi è già qui
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript in StarterPlayerScripts chiamato NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local player = Players.LocalPlayer

-- Un piccolo banner in alto sullo schermo, costruito nel codice
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

-- Qui non c'è il parametro player: il server ha già scelto chi riceve il messaggio
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 -- lo nascondiamo se non l'ha sostituito un messaggio più recente
			label.Visible = false
		end
	end)
end)

Il server invia il messaggio su PlayerAdded, e questo può succedere prima che il LocalScript colleghi il suo gestore. Va bene così: Roblox mette in coda i messaggi RemoteEvent arrivati prima che esista un gestore e li consegna in ordine appena il gestore si collega.

Il client non deve difendersi dal server: OnClientEvent può farlo scattare solo il codice del server. L'annotazione message: string serve al controllo dei tipi; non è un controllo durante l'esecuzione.

Schema 3: dal server a tutti i client

FireAllClients invia lo stesso messaggio a ogni giocatore connesso. Non ha un argomento Player, e ogni client riceve il messaggio nello stesso OnClientEvent di prima, quindi lo script NotifyClient dello schema 2 lo mostra già.

Questo Script annuncia a tutti quando un giocatore tocca per la prima volta il traguardo. Aggiungi in Workspace una Part ancorata chiamata FinishLine, poi aggiungi lo Script in ServerScriptService.

Script in ServerScriptService chiamato 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 -- non è un giocatore o è già stato annunciato
	end
	finished[player] = true

	-- Ogni client connesso esegue il suo gestore OnClientEvent con questo testo
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

Un exploiter può far scattare Touched per il suo personaggio da qualsiasi distanza, ma per un annuncio mostrato una volta per giocatore è innocuo. Se più avanti darai una ricompensa per l'arrivo, aggiungi controlli sul server prima di assegnarla, per esempio un tempo minimo dall'inizio del round.

FireAllClients raggiunge solo i giocatori connessi in quel momento. Chi entra un secondo dopo non vedrà più il messaggio. Va bene per momenti singoli, come un annuncio, l'effetto di un'esplosione o un suono, ma non va bene per uno stato come il timer del round o la fase attuale del gioco. Per lo stato imposta sul server un attributo, per esempio ReplicatedStorage:SetAttribute("TimeLeft", 30), e leggilo sul client con GetAttribute e GetAttributeChangedSignal("TimeLeft"). Gli attributi si replicano a ogni client, compresi i giocatori entrati più tardi.

RemoteFunction: quando il client ha bisogno di una risposta

Un RemoteEvent funziona secondo il principio «invia e dimentica». Una RemoteFunction fa aspettare il chiamante: InvokeServer mette in pausa il codice che l'ha chiamata finché la funzione OnServerInvoke del server non restituisce un valore, e poi consegna quello che ha restituito. Usala quando il client non può proseguire senza la risposta, per esempio «questo codice era giusto?». Quando la risposta non serve, Roblox consiglia un RemoteEvent, perché non aspetta.

Esempio: un campo in cui i giocatori scrivono un codice promozionale. Il server tiene i codici, controlla il testo e restituisce due valori: se ha funzionato e il messaggio da mostrare.

  1. In ReplicatedStorage.Remotes inserisci una RemoteFunction chiamata RedeemCode.
  2. In StarterGui inserisci una ScreenGui chiamata CodeGui, e dentro una TextBox chiamata CodeBox. Dimensione e posizione scegli tu.
  3. Aggiungi lo Script qui sotto in ServerScriptService e il LocalScript dentro CodeBox.
Script in ServerScriptService chiamato RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- I codici vivono sul server, dove nessun giocatore può leggerli
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 } = {}

-- Si assegna con =. OnServerInvoke è un callback, non un evento a cui fare 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)

Aggiunge alla statistica Coins della guida alla classifica. I codici usati vengono ricordati solo finché il giocatore non esce, quindi in questa forma un giocatore può rientrare e inserire di nuovo lo stesso codice. Se le monete vengono salvate, sono monete gratis a ogni rientro: prima di usarlo in un gioco pubblicato, salva i codici usati da ogni giocatore insieme ai suoi dati nel DataStore.

LocalScript in TextBox CodeBox chiamato 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 mette in pausa questa funzione finché il callback del server non restituisce un valore.
	-- pcall impedisce al LocalScript di fermarsi se la chiamata fallisce.
	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)

Una RemoteFunction ha esattamente un callback sul server. Se due script impostano OnServerInvoke sulla stessa RemoteFunction, funziona solo l'ultimo.

Perché InvokeClient è pericoloso

Una RemoteFunction funziona anche nella direzione opposta, con InvokeClient sul server e OnClientInvoke sul client. La documentazione di Roblox elenca tre rischi seri:

  • Se il callback del client va in errore, va in errore anche il server.
  • Se il giocatore esce durante la chiamata, InvokeClient va in errore.
  • Se il client non restituisce mai un valore, lo script del server aspetterà per sempre.

Un client modificato controlla il proprio callback, quindi un cheater può provocare di proposito il terzo caso e tenere bloccato quel thread del server quanto vuole. Per aggiornare lo schermo di un giocatore usa FireClient. Se il server ha davvero bisogno di un'informazione dal client, invia un RemoteEvent, lascia che il client risponda con un altro RemoteEvent, e sul server tratta la mancata risposta come un caso normale.

Controlla ogni argomento sul server

Un exploiter può chiamare qualsiasi RemoteEvent o RemoteFunction tutte le volte che vuole e con qualsiasi argomento. L'unica cosa che non può falsificare è il primo parametro: Roblox inserisce da solo il Player che ha inviato il messaggio. Tutto quello che viene dopo va controllato prima che il server agisca. Nascondere il remote o fare i controlli in un LocalScript non serve, perché il cheater controlla il proprio client.

Lista dei controlli per il server
ControlloLa domanda che si fa il serverEsempio
TipoÈ il tipo che mi aspetto? Un Instance, e non una tabella costruita per sembrarlo?typeof(part) == "Instance" and part:IsA("BasePart")
IntervalloIl numero è finito e sta nei limiti consentiti? Il testo ha una lunghezza ragionevole?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
AppartenenzaQuesto giocatore possiede l'oggetto, ha abbastanza soldi, ha il diritto di agire su quest'oggetto?L'oggetto è nel suo inventario; la parte sta dentro Paintable
DistanzaIl personaggio del giocatore è abbastanza vicino nella copia del mondo sul server? Lascia un piccolo margine per il lag.Non più di 30 stud dalla parte
FrequenzaQuesto giocatore sta inviando troppo spesso?Un cooldown per giocatore o un limite con accumulo di chiamate

NaN merita un avviso a parte. È un numero, quindi type(x) == "number" passa, ma qualsiasi confronto con NaN dà false, e un controllo come x < 0 or x > 100 lo lascia passare. math.isfinite(x) rifiuta NaN ed entrambi gli infiniti.

Ricorda il limite del controllo della distanza. Ogni client gestisce la fisica del proprio personaggio, quindi un exploiter può spostare il personaggio vicino al bersaglio prima della chiamata. Il controllo blocca comunque l'abuso più semplice, agire su tutta la mappa da un solo punto. Tieni ancorate le parti bersaglio: la documentazione di Roblox sulla sicurezza nota che un exploiter può ottenere la proprietà di rete delle parti non ancorate vicino a sé e avvicinarle, e questo aggira il controllo della distanza.

Ecco gli stessi controlli sotto forma di ModuleScript, da usare in ogni gestore di remote.

ModuleScript in ServerScriptService chiamato RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Un numero vero tra min e max. Rifiuta NaN e infinito, che superano
-- il normale controllo 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 intero tra min e max, per quantità, indici e contatori
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

-- Testo con lunghezza limitata. utf8.len restituisce nil per UTF-8 non valido, che
-- i DataStore rifiutano.
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 della classe prevista dentro un contenitore che hai consentito.
-- Una tabella costruita per sembrare un Instance non supera il controllo 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 quando il personaggio del giocatore è a non più di maxDistance stud da 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

-- Limite di frequenza per giocatore. Ogni giocatore può fare `burst` chiamate subito e
-- ne riottiene `perSecond` ogni secondo. Restituisce una funzione da chiamare
-- prima del lavoro: risponde true (si può) o false (troppo spesso).
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

Tienilo in ServerScriptService. Il codice che sta lì non arriva mai ai client, quindi nessuno potrà leggere i tuoi controlli.

Ed ecco il gestore dello schema 1, riscritto usandolo. Sostituisci il contenuto di PaintServer:

Script in ServerScriptService chiamato PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" conta solo per il controllo dei tipi strict di Luau; durante l'esecuzione non cambia nulla
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) -- raffica di 4, poi 4 al secondo

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)

Il limitatore cancella la voce del giocatore quando esce, quindi la sua tabella non cresce per tutta la vita del server.

Nelle armi questi controlli contano più che altrove: non lasciare mai che sia il client a dire chi è stato colpito. Il remote della guida alla spada non porta nessun argomento, e i bersagli li trova il server da solo. La guida alle armi da fuoco (in inglese) invia solo il punto di mira, che il server controlla per tipo, NaN e distanza prima di lanciare il proprio raggio.

I menu seguono la stessa regola: invia la scelta, non il risultato. Nella guida ai dialoghi con gli NPC il client invia solo il numero del pulsante premuto, e il server guarda da solo cosa dà quella risposta. Il menu della guida al teletrasporto invia il nome del punto, non la posizione, e il server trova il punto nella sua cartella e controlla quante Wins servono.

Cosa si può e cosa non si può inviare

Si possono passare numeri, stringhe, valori booleani, tipi Roblox come Vector3, CFrame, Color3 e gli elementi di Enum, gli Instance che vedono entrambe le parti, e tabelle fatte di tutto questo. Alcuni valori lungo la strada cambiano o spariscono:

Argomenti che arrivano diversi da come sono stati inviati
InviiCosa succede
Una funzioneL'altra parte riceve nil
Una tabella con una metatabellaLa metatabella si perde, insieme a tutto quello che la tabella aveva solo grazie a lei
Una tabella con chiavi numeriche e di testo mescolateRoblox consiglia di non farlo: invia un array puro o un dizionario puro
Una tabella con valori nil dentroEvitalo: Roblox sconsiglia nil a qualsiasi indice
Una tabella con chiavi di tipo Instance, userdata o functionQueste chiavi diventano stringhe
Un Instance che chi riceve non vede, per esempio da ServerStorage o creato in un LocalScriptL'altra parte riceve nil
Qualsiasi tabellaChi riceve ottiene una copia, non la stessa tabella

Una buona abitudine: invia identificatori, non oggetti o valori. Il nome di un oggetto, il numero di un'opzione, una parte che il server può trovare e controllare. Da lì il server lavora con i propri dati.

Perché una RemoteFunction restituisce nil

Se InvokeServer ti restituisce nil, controlla questi punti in ordine:

  1. Un percorso senza valore di ritorno. Ogni uscita da OnServerInvoke deve restituire qualcosa. Un return vuoto in un controllo iniziale rimanda indietro nil.
  2. return dentro una funzione annidata. Un return dentro pcall(function() ... end), un gestore :Connect o task.spawn esce solo da quella funzione interna. Salva il risultato, per esempio local ok, data = pcall(...), e poi restituisci data dal callback stesso.
  3. Un valore che non può attraversare il confine. Una funzione o un Instance che il client non vede (per esempio qualsiasi cosa in ServerStorage) arriva come nil. Con l'instance streaming attivo, una parte appena creata dal server potrebbe non essere ancora arrivata al client quando la funzione restituisce il valore.
  4. Il callback l'ha impostato un altro script. Funziona solo l'ultima assegnazione di OnServerInvoke. Cerca il nome del remote nei tuoi script.

Se la chiamata non ritorna proprio, nessuno script ha ancora impostato OnServerInvoke (Roblox tiene le chiamate in coda finché non viene impostato) oppure il callback si è bloccato, per esempio su un WaitForChild per qualcosa che non comparirà mai.

UnreliableRemoteEvent: per aggiornamenti continui e usa e getta

Un UnreliableRemoteEvent ha gli stessi metodi ed eventi di un RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent e OnClientEvent. La differenza è che Roblox non garantisce né la consegna né l'ordine. Un messaggio può essere scartato senza un nuovo invio quando:

  • si perde per strada o aspetta troppo a lungo su una rete congestionata
  • i suoi dati superano i 1000 byte
  • il client invia più spesso del limite (l'eccesso viene scartato, non rimandato)
  • al suo arrivo non è collegato nessun gestore (viene buttato, non messo in coda)

I messaggi possono anche arrivare fuori ordine, e il loro ordine non ha alcun legame con i tuoi RemoteEvent o RemoteFunction. Usalo quando conta solo il valore più recente e il prossimo aggiornamento arriverà tra una frazione di secondo: dove mira il giocatore, la posizione di un effetto cosmetico, un valore che cambia a ogni frame. Se l'ordine conta, metti in ogni messaggio un numero progressivo o un timestamp e ignora tutto ciò che è più vecchio dell'ultimo gestito.

Non usarlo mai per qualcosa che deve succedere esattamente una volta, come un acquisto, un danno, una ricompensa o l'inizio di un round. E controlla i suoi argomenti sul server esattamente come quelli di un RemoteEvent.

Ordine di consegna e limiti di frequenza

Le garanzie di consegna di Roblox valgono per una connessione in una direzione: dal server a un client o da un client al server.

  • I RemoteEvent sono affidabili e ordinati. I messaggi persi vengono reinviati finché chi riceve resta connesso, e i messaggi arrivano nell'ordine in cui li hai inviati, anche attraverso RemoteEvent diversi. Se il server invia a un giocatore A, poi B, poi A, quel giocatore riceve A, B, A.
  • L'ordine riguarda il momento in cui partono i gestori. Se un gestore cede il controllo, per esempio con task.wait o WaitForChild, il messaggio successivo può iniziare a essere gestito prima che finisca il primo.
  • RemoteFunction e RemoteEvent non sono ordinati tra loro. Se il tuo codice dipende da un ordine rigoroso, invia i messaggi collegati con un solo tipo di remote o aggiungi un tuo numero progressivo.
  • I cambi di proprietà e attributi non sono ordinati rispetto ai remote. Se il server cambia una proprietà e poi chiama un remote, il client può vedere per primo l'uno o l'altro. Ascolta il cambiamento stesso, per esempio con GetPropertyChangedSignal, invece di dare per scontato che sia già arrivato.
  • Il gestore non c'è ancora. I messaggi RemoteEvent restano in coda finché non si collega un gestore. La coda ha dei limiti: quando è piena, i messaggi successivi vengono scartati e nell'Output compare l'errore Remote event invocation discarded.
  • Un giocatore che esce perde tutti i messaggi che non gli sono ancora arrivati.

Limite di frequenza. I messaggi RemoteEvent e UnreliableRemoteEvent dal client al server sono limitati a circa 500 richieste al secondo per client, secondo la documentazione al 30 settembre 2026. Il limite è condiviso da tutti i remote dello stesso tipo, quindi dividere un remote molto usato in dieci non lo alza. Oltre il limite, i messaggi RemoteEvent vengono gestiti più tardi e mantengono l'ordine, mentre quelli UnreliableRemoteEvent vengono scartati. Il limite del motore non impedisce in alcun modo a un giocatore di chiamare il tuo remote 50 volte al secondo, quindi ogni gestore che cambia qualcosa ha comunque bisogno di un suo limite per giocatore.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent o attributo?

Come scegliere il modo in cui client e server comunicano
UsaPer cosaEsempioA cosa fare attenzione
RemoteEventMessaggi in una direzione che devono arrivare, e in ordineClient: «colora questa parte». Server: «mostra questa notifica»Controlla ogni argomento sul server
RemoteFunction con InvokeServerIl client ha bisogno di una risposta prima di poter proseguireInserire un codice promozionale, confermare un acquistoIl chiamante aspetta; ogni percorso deve restituire un valore
RemoteFunction con InvokeClientQuasi maiUsa invece FireClientUn client che va in errore, esce o non risponde rompe o blocca la chiamata sul server
UnreliableRemoteEventAggiornamenti frequenti in cui conta solo l'ultimoDirezione della mira, effetti cosmeticiI messaggi si perdono o cambiano ordine; limite di dati di 1000 byte
Attributo o oggetto value impostato dal serverUno stato condiviso che deve essere sempre visibile, anche ai giocatori entrati più tardiTimer del round, fase del gioco, se una porta è apertaA tutti arrivano solo i cambiamenti del server; i client ascoltano con GetAttributeChangedSignal o Changed
BindableEventComunicazione tra script dalla stessa parteUno script del server dice a un altro che il round è finitoNon passa tra server e client

Per un esempio completo di come RemoteFunction e controlli lavorano insieme dove i giocatori pagano, guarda la guida come fare una GUI del negozio. Quanto alla riga sugli attributi, lo script del server della guida alle porte imposta un attributo Open su ogni porta a ogni suo movimento, così qualsiasi LocalScript può reagire.

Errori comuni e soluzioni

La maggior parte dei problemi con i remote si vede nella finestra Output (aprila dal menu Window o dalla scheda Script). Guarda prima lì, poi cerca qui sotto il tuo sintomo. La guida agli errori degli script spiega più nel dettaglio i messaggi di errore comuni.

Infinite yield possible su WaitForChild per un remote

Lo script aspetta un remote che non comparirà mai. Controlla che il nome e le maiuscole coincidano esattamente e che il remote stia in ReplicatedStorage, non in ServerStorage o ServerScriptService, che i client non vedono.

Il server riceve valori sbagliati, spostati di uno

Il LocalScript ha passato il giocatore stesso, come in remote:FireServer(player, 5). Roblox aggiunge già chi invia come primo parametro, quindi il server vede (player, player, 5). Chiama remote:FireServer(5).

Non succede nulla quando chiamo il remote

Controlla che ogni chiamata venga dalla parte giusta: FireServer e InvokeServer funzionano solo dal codice del client, mentre FireClient, FireAllClients e InvokeClient solo da uno Script del server. Un LocalScript non parte mai in ServerScriptService, ServerStorage o direttamente in Workspace; mettilo in StarterPlayerScripts, StarterGui, StarterCharacterScripts o StarterPack. Poi cerca nell'Output un errore dentro il gestore.

Remote event invocation discarded

Sono arrivati messaggi per un RemoteEvent che non aveva un gestore collegato, e la coda si è riempita. Di solito lo script con il gestore va in errore prima della riga con :Connect, è disattivato o è bloccato ad aspettare qualcosa che non si caricherà mai. Collega i gestori verso l'inizio dello script.

A me funziona, ma gli altri giocatori non vedono il cambiamento

Il cambiamento è fatto sul client, in un LocalScript o in un gestore OnClientEvent. Fallo nel gestore OnServerEvent sul server.

InvokeServer non ritorna mai

O nessuno script ha impostato OnServerInvoke (Roblox tiene le chiamate in coda finché non viene impostato), oppure il callback è bloccato su qualcosa che cede il controllo, come WaitForChild o una richiesta al DataStore. Aggiungi un print all'inizio e alla fine del callback per vedere dove si ferma.

Farlo con RoCode

Anche RoCode può preparare tutto questo, direttamente nel place che hai aperto. RoCode è un agente IA che lavora tramite un plugin per Roblox Studio, quindi crea remote e script nel tuo Explorer invece di darti codice da incollare.

Tu scrivi

Fai in modo che i giocatori colorino con un clic le parti nella cartella Paintable. Usa un RemoteEvent e lascia i controlli sul server: solo le parti di quella cartella, non oltre 30 stud e non più di qualche colorazione al secondo.

RoCode fa
  • Di solito prima esamina il place con Search Game e Search Scripts per cercare una cartella Remotes o un gestore già pronti, e usa le tue cartelle se ci sono
  • Crea il RemoteEvent in ReplicatedStorage con Create Instance e scrive lo Script del server e il LocalScript con Create Script
  • Prima di finire controlla la compilazione di ogni script con Check Script dentro Studio. Questo trova gli errori di compilazione, non quelli di logica: non controlla i tipi, non esegue un linter e non esegue il tuo codice
  • Invia le modifiche a blocchi, e ogni blocco è un punto di annullamento nella cronologia di Studio

Con il plugin 3.9 o successivo RoCode può avviare un breve playtest e leggere gli errori, e con il plugin 3.9.11 o successivo può guidare un personaggio di test, ma non clicca sulle parti nella finestra 3D. Premi Play tu e prova a rompere i controlli, per esempio colorando una parte dall'altro capo della mappa. Se compare un errore, Check Output può leggere le righe Server e Client del tuo ultimo playtest. La maggior parte dei sistemi di gioco comunica con remote come questi, quindi li ritroverai quando costruirai un gioco sistema per sistema con RoCode. Come RoCode si collega a Studio.

Domande frequenti

Cosa significa securing the client-server boundary su Roblox?

È il nome della pagina della documentazione di Roblox sulla sicurezza dei remote, e l'idea è semplice: tutto quello che il client invia tramite un RemoteEvent o una RemoteFunction può venire da un exploiter, quindi il server lo controlla prima di agire. Controlla il tipo di ogni argomento, tieni i numeri in limiti ragionevoli, verifica che al giocatore sia permesso farlo in quel momento e limita quanto spesso ogni giocatore può chiamare il remote. La lista dei controlli qui sopra li mostra tutti nel codice.

È sicuro usare una RemoteFunction?

InvokeServer è sicuro quanto il tuo callback sul server: controlla i suoi argomenti e limita la frequenza come per qualsiasi RemoteEvent. La direzione rischiosa è InvokeClient, perché un client che va in errore, esce o non restituisce mai un valore rompe o blocca la chiamata sul server.

Gli exploiter possono vedere e chiamare i miei remote?

Sì. Tutto quello che sta in ReplicatedStorage arriva a ogni client, e un client modificato può chiamare qualsiasi remote con qualsiasi argomento. Rinominare o nascondere i remote non li rende sicuri; a renderli sicuri è il controllo di ogni argomento sul server.

Un client può inviare un RemoteEvent a un altro client?

Direttamente no. Invialo al server, controllalo lì, poi usa FireClient o FireAllClients.

Quanto spesso si può chiamare un RemoteEvent?

La documentazione di Roblox indica un limite di circa 500 richieste al secondo per client per i messaggi RemoteEvent e UnreliableRemoteEvent inviati al server, condiviso da tutti i remote dello stesso tipo. Resta molto al di sotto e dai a ogni gestore un suo limite per giocatore.

FireAllClients raggiunge i giocatori entrati più tardi?

No. Raggiunge i giocatori connessi in quel momento. Per uno stato che serve a chi arriva dopo, imposta sul server un attributo o un oggetto value.

Qual è la differenza tra RemoteEvent e BindableEvent?

Un RemoteEvent passa tra server e client. Un BindableEvent collega script dalla stessa parte, per esempio due script del server.

Fonti e letture

Come è stato controllato il codice: ogni script di questa pagina supera il controllo dei tipi rigoroso di Luau con le definizioni dell'API di Roblox (luau-lsp, 20 novembre 2026). Il controllo dei tipi trova API scritte male e tipi sbagliati, non la logica del gioco, quindi provalo in Studio prima di pubblicare.

Prova RoCode nel tuo gioco.

Crediti gratis ogni giorno, senza carta. Installa il plugin, descrivi la funzione e controlla cosa compare in Studio.