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 (
InvokeServereOnServerInvoke) solo quando il client ha bisogno di una risposta. EvitaInvokeClient: 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
A cosa servono i RemoteEvent
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.
| Direzione | Chi invia chiama | Chi riceve si collega a | Chi riceve ottiene |
|---|---|---|---|
| Dal client al server | remote:FireServer(...) in un LocalScript | remote.OnServerEvent in uno Script | Il Player che ha inviato il messaggio, poi i tuoi argomenti |
| Dal server a un client | remote:FireClient(player, ...) in uno Script | remote.OnClientEvent in un LocalScript | Solo i tuoi argomenti |
| Dal server a tutti i client | remote:FireAllClients(...) in uno Script | remote.OnClientEvent in un LocalScript | Solo i tuoi argomenti |
| Il client chiede, il server risponde | remoteFunction: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.
- Nell'Explorer passa il mouse su ReplicatedStorage, clicca sul pulsante + e inserisci un Folder. Chiama la cartella
Remotes. - Passa il mouse su
Remotes, clicca su + e inserisci un RemoteEvent. Rinominalo con un nome che ne descriva lo scopo, per esempioPaintRequest. - Ripeti per ogni remote. Questa guida usa due RemoteEvent (
PaintRequesteNotify) e una 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
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.
- In Workspace inserisci un Folder chiamato
Paintablee mettici dentro alcune Part ancorate. - Controlla che in
ReplicatedStorage.Remotesci sia un RemoteEvent chiamatoPaintRequest. - Inserisci uno Script chiamato
PaintServerin ServerScriptService e un LocalScript chiamatoPaintClientin StarterPlayer, StarterPlayerScripts, con il codice qui sotto.
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.
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.
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
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.
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.
- In
ReplicatedStorage.Remotesinserisci una RemoteFunction chiamataRedeemCode. - In StarterGui inserisci una ScreenGui chiamata
CodeGui, e dentro una TextBox chiamataCodeBox. Dimensione e posizione scegli tu. - Aggiungi lo Script qui sotto in ServerScriptService e il LocalScript dentro
CodeBox.
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.
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,
InvokeClientva 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.
| Controllo | La domanda che si fa il server | Esempio |
|---|---|---|
| Tipo | È il tipo che mi aspetto? Un Instance, e non una tabella costruita per sembrarlo? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Intervallo | Il numero è finito e sta nei limiti consentiti? Il testo ha una lunghezza ragionevole? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Appartenenza | Questo 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 |
| Distanza | Il 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 |
| Frequenza | Questo 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.
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:
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:
| Invii | Cosa succede |
|---|---|
| Una funzione | L'altra parte riceve nil |
| Una tabella con una metatabella | La metatabella si perde, insieme a tutto quello che la tabella aveva solo grazie a lei |
| Una tabella con chiavi numeriche e di testo mescolate | Roblox consiglia di non farlo: invia un array puro o un dizionario puro |
Una tabella con valori nil dentro | Evitalo: Roblox sconsiglia nil a qualsiasi indice |
| Una tabella con chiavi di tipo Instance, userdata o function | Queste chiavi diventano stringhe |
| Un Instance che chi riceve non vede, per esempio da ServerStorage o creato in un LocalScript | L'altra parte riceve nil |
| Qualsiasi tabella | Chi 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:
- Un percorso senza valore di ritorno. Ogni uscita da
OnServerInvokedeve restituire qualcosa. Unreturnvuoto in un controllo iniziale rimanda indietronil. - return dentro una funzione annidata. Un
returndentropcall(function() ... end), un gestore:Connectotask.spawnesce solo da quella funzione interna. Salva il risultato, per esempiolocal ok, data = pcall(...), e poi restituiscidatadal callback stesso. - 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. - 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.waitoWaitForChild, 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?
| Usa | Per cosa | Esempio | A cosa fare attenzione |
|---|---|---|---|
| RemoteEvent | Messaggi in una direzione che devono arrivare, e in ordine | Client: «colora questa parte». Server: «mostra questa notifica» | Controlla ogni argomento sul server |
RemoteFunction con InvokeServer | Il client ha bisogno di una risposta prima di poter proseguire | Inserire un codice promozionale, confermare un acquisto | Il chiamante aspetta; ogni percorso deve restituire un valore |
RemoteFunction con InvokeClient | Quasi mai | Usa invece FireClient | Un client che va in errore, esce o non risponde rompe o blocca la chiamata sul server |
| UnreliableRemoteEvent | Aggiornamenti frequenti in cui conta solo l'ultimo | Direzione della mira, effetti cosmetici | I messaggi si perdono o cambiano ordine; limite di dati di 1000 byte |
| Attributo o oggetto value impostato dal server | Uno stato condiviso che deve essere sempre visibile, anche ai giocatori entrati più tardi | Timer del round, fase del gioco, se una porta è aperta | A tutti arrivano solo i cambiamenti del server; i client ascoltano con GetAttributeChangedSignal o Changed |
| BindableEvent | Comunicazione tra script dalla stessa parte | Uno script del server dice a un altro che il round è finito | Non 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (in inglese). FireServer, FireClient, InvokeServer, rischi di InvokeClient, limiti degli argomenti e garanzie di consegna
- Roblox Creator Docs: Securing the client-server boundary (in inglese). Livelli di controllo, NaN, limiti di frequenza, inoltro da client a client
- Roblox Creator Docs: Security and cheat mitigation tactics (in inglese). Cosa può fare un client modificato e l'autorità del server
- Roblox Creator Docs: Network ownership, movement validation, and physics (in inglese). Perché il client controlla il proprio personaggio e i limiti dei controlli della distanza
- Roblox Engine API: RemoteEvent (in inglese). Limite di frequenza ed errore invocation discarded
- Roblox Engine API: RemoteFunction (in inglese). OnServerInvoke, avvisi su InvokeClient e precauzioni con lo streaming
- Roblox Engine API: UnreliableRemoteEvent (in inglese). Limite di dati di 1000 byte
- Roblox Creator Docs: Properties and attributes (in inglese). Ordine di replica tra cambi di proprietà e remote events
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.