En bref
Un RemoteEvent est un objet, rangé en général dans ReplicatedStorage, qui envoie des messages à travers la frontière entre client et serveur. Un LocalScript appelle FireServer et le serveur le reçoit sur OnServerEvent, avec le Player expéditeur ajouté en premier argument. Le serveur appelle FireClient(player, ...) ou FireAllClients(...), et les LocalScripts le reçoivent sur OnClientEvent.
- N'utilise une RemoteFunction (
InvokeServeretOnServerInvoke) que quand le client a besoin d'une réponse. ÉviteInvokeClient: un client qui plante, qui part ou qui ne répond jamais casse l'appel du serveur. - Ne fais jamais confiance à ce qu'envoie un client. Sur le serveur, vérifie le type, la plage et la propriété de chaque argument, la distance du joueur, et la fréquence de ses envois.
- Les fonctions, les metatables et les objets que l'autre côté ne peut pas voir ne survivent pas au trajet. Un UnreliableRemoteEvent peut perdre des messages ou les livrer dans le désordre, et il abandonne toute charge de plus de 1 000 octets.
Sur cette page
Pourquoi les RemoteEvents existent
Chaque jeu Roblox tourne sur un serveur plus un client par joueur. Le serveur fait autorité : un nouvel objet ou un changement de propriété n'arrive chez tous les joueurs que si c'est le serveur qui le fait. Un changement fait dans un LocalScript reste sur ce seul appareil, à quelques exceptions près comme le personnage du joueur, dont son client contrôle les déplacements. Donc quand un clic ou une touche doit changer le monde partagé, le client doit demander au serveur, et quand le serveur veut que l'écran d'un joueur réagisse, il doit le dire à ce client. Si la séparation entre Script et LocalScript est nouvelle pour toi, lis d'abord Script vs LocalScript vs ModuleScript (en anglais). Si c'est le scripting lui-même qui est nouveau, commence par comment scripter sur Roblox Studio.
Roblox te donne trois objets pour franchir cette frontière :
- RemoteEvent : un message à sens unique. L'expéditeur continue tout de suite.
- RemoteFunction : une demande qui attend une réponse. L'appelant se met en pause jusqu'à ce que l'autre côté renvoie une valeur.
- UnreliableRemoteEvent : un message à sens unique qui peut être perdu ou arriver dans le désordre, en échange d'une charge réseau plus faible. Il convient aux données qui changent en permanence.
| Sens | L'expéditeur appelle | Le destinataire se connecte à | Le destinataire reçoit |
|---|---|---|---|
| Du client au serveur | remote:FireServer(...) dans un LocalScript | remote.OnServerEvent dans un Script | Le Player qui a envoyé, puis tes arguments |
| Du serveur à un client | remote:FireClient(player, ...) dans un Script | remote.OnClientEvent dans un LocalScript | Tes arguments seulement |
| Du serveur à tous les clients | remote:FireAllClients(...) dans un Script | remote.OnClientEvent dans un LocalScript | Tes arguments seulement |
| Le client demande, le serveur répond | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Le Player, puis tes arguments. L'appelant récupère ce que la fonction renvoie |
Les clients ne peuvent pas s'envoyer de messages directement. Pour faire passer quelque chose d'un joueur aux autres, envoie-le au serveur, vérifie-le là, et laisse le serveur le transmettre avec FireClient ou FireAllClients. La consigne de sécurité de Roblox est que le serveur joue ici le rôle de gardien, jamais de simple relais.
Où mettre tes remotes
Un remote doit se trouver là où le serveur et les clients peuvent le voir tous les deux. L'endroit habituel est ReplicatedStorage ; la documentation de Roblox note que Workspace ou un Tool peuvent aussi convenir dans certains cas. ServerStorage et ServerScriptService sont réservés au serveur, donc un LocalScript qui attend un remote à cet endroit attend pour toujours.
- Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un Folder. Nomme-le
Remotes. - Survole
Remotes, clique sur + et insère un RemoteEvent. Renomme-le pour décrire son rôle, par exemplePaintRequest. - Recommence pour chaque remote. Ce guide utilise deux RemoteEvents (
PaintRequestetNotify) et une 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
Les scripts de ce guide trouvent les remotes avec WaitForChild. Il répond tout de suite quand le remote est déjà là et attend quand il ne l'est pas, par exemple quand un script serveur crée des remotes pendant que le jeu tourne. Utilise un remote par type de demande : chaque gestionnaire serveur vérifie alors une seule forme d'arguments, ce qui est bien plus facile à réussir qu'un remote unique qui fait tout.
Schéma 1 : du client au serveur, vérifié par le serveur
Le cas le plus courant : le joueur fait quelque chose sur son écran, et le serveur décide de ce qui se passe. Ici, le joueur appuie sur Q pour choisir une couleur parmi quatre et clique ou touche une part pour la peindre. Tout le monde voit la nouvelle couleur, parce que c'est le serveur qui peint.
Le client envoie deux choses : quelle part, et un numéro de couleur. Il n'envoie jamais la couleur elle-même, et dans d'autres jeux il ne devrait jamais envoyer un prix, une récompense ou un montant de dégâts. Un client modifié peut envoyer n'importe quoi, donc le serveur garde les vraies données (ici, la palette) et traite les arguments comme une demande à vérifier.
- Dans Workspace, insère un Folder nommé
Paintableet mets-y quelques Parts ancrées. - Vérifie que
ReplicatedStorage.Remotescontient un RemoteEvent nomméPaintRequest. - Insère un Script dans ServerScriptService nommé
PaintServer, et un LocalScript dans StarterPlayer, StarterPlayerScripts nomméPaintClient, avec le code ci-dessous.
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")
-- Les couleurs appartiennent au serveur. Le client n'envoie qu'un numéro qui en choisit une.
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 entre le personnage et la part
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- Le premier paramètre est toujours le joueur qui a envoyé. Roblox le remplit,
-- donc on peut s'y fier. Tout ce qui suit vient du client, et on ne peut pas s'y fier.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Type : une vraie part, pas une table qui se fait passer pour une part
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Plage : un nombre entier de 1 à 4. NaN et l'infini échouent ici aussi.
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. Cible autorisée : seulement les parts du dossier Paintable, rien d'autre dans le jeu
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Distance : le personnage du joueur doit être près de la 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. Limite de fréquence : une peinture par joueur tous les quarts de seconde
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)
Chaque vérification ratée fait simplement un return. Il n'y a pas besoin de dire à un client qui triche pourquoi il a été refusé.
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 -- le serveur détient les vraies couleurs
local selectedColour = 1
-- Ne laisse le rayon toucher que les parts du dossier 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 -- la touche ou le clic est allé au chat ou à un bouton
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
-- Demande, n'ordonne pas : le serveur décide si la peinture a lieu
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed vaut true quand le moteur a déjà réagi à l'entrée, en général dans l'interface : un clic sur un bouton, ou des touches tapées dans une zone de texte comme la barre de chat. Le vérifier fait que taper un Q dans un message ne change pas la couleur.
Schéma 2 : du serveur à un client
Le serveur envoie un message à un joueur avec FireClient. Le premier argument est le Player à qui l'envoyer, et le gestionnaire du client ne reçoit que les arguments qui suivent. Utilise ça pour tout ce qui est personnel : une notification, une fenêtre de récompense, un son que seul ce joueur doit entendre. Le guide des cinématiques en est un exemple plus poussé : le serveur décide quand un joueur voit une cinématique et envoie ses plans à ce seul joueur avec FireClient, et c'est son appareil qui déplace la caméra.
Cette paire affiche un message de bienvenue quand un joueur arrive. Le LocalScript construit sa propre petite bannière, donc il n'y a aucune interface à préparer.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local function welcome(player: Player)
-- Le premier argument choisit quel client le reçoit. Personne d'autre ne voit ça.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- Dans Studio, tu peux arriver avant que ce script se connecte, donc salue ceux qui sont déjà là
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
-- Une petite bannière en haut de l'écran, construite en code
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
-- Pas de paramètre player ici : le serveur a déjà choisi qui le reçoit
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 -- cache-la sauf si un message plus récent l'a remplacée
label.Visible = false
end
end)
end)
Le serveur envoie sur PlayerAdded, ce qui peut arriver avant que ce LocalScript ait connecté son gestionnaire. Ce n'est pas un problème : Roblox met en file d'attente les messages de RemoteEvent qui arrivent avant qu'un gestionnaire existe et les livre, dans l'ordre, dès qu'un gestionnaire se connecte.
Le client n'a pas besoin de se protéger du serveur : seul du code serveur peut déclencher OnClientEvent. L'annotation message: string sert au vérificateur de types ; ce n'est pas une vérification à l'exécution.
Schéma 3 : du serveur à tous les clients
FireAllClients envoie le même message à tous les joueurs connectés. Il ne prend pas d'argument Player, et chaque client le reçoit sur le même OnClientEvent qu'avant, donc le script NotifyClient du schéma 2 l'affiche déjà.
Ce Script annonce à tout le monde quand un joueur touche une ligne d'arrivée pour la première fois. Ajoute une Part ancrée nommée FinishLine dans Workspace, puis ajoute le Script dans 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 -- pas un joueur, ou déjà annoncé
end
finished[player] = true
-- Chaque client connecté lance son gestionnaire OnClientEvent avec ce texte
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
Un exploiteur peut déclencher Touched pour son propre personnage à n'importe quelle distance, ce qui est sans danger pour une annonce affichée une fois par joueur. Si tu donnes plus tard une récompense à l'arrivée, ajoute des vérifications serveur avant de payer, par exemple un temps minimum depuis le début de la manche.
FireAllClients n'atteint que les joueurs connectés à ce moment-là. Quelqu'un qui arrive une seconde plus tard ne voit jamais le message. C'est adapté aux moments ponctuels, comme une annonce, un effet d'explosion ou un son, mais pas à un état comme le chrono d'une manche ou la phase de jeu en cours. Pour un état, règle un attribut sur le serveur, par exemple ReplicatedStorage:SetAttribute("TimeLeft", 30), et lis-le sur le client avec GetAttribute et GetAttributeChangedSignal("TimeLeft"). Les attributs sont répliqués à tous les clients, y compris aux joueurs qui arrivent plus tard.
RemoteFunction : quand le client a besoin d'une réponse
Un RemoteEvent, c'est envoyer et oublier. Une RemoteFunction fait attendre l'appelant : InvokeServer met en pause le code qui l'a appelé jusqu'à ce que la fonction OnServerInvoke du serveur fasse son return, puis lui remet ce qu'elle a renvoyé. Utilise-la quand le client ne peut pas continuer sans la réponse, par exemple "ce code était-il valide ?". Quand tu n'as pas besoin de réponse, Roblox recommande un RemoteEvent, parce qu'il n'attend pas.
Exemple : une zone où les joueurs tapent un code de récompense. Le serveur détient les codes, vérifie le texte, et renvoie deux valeurs : si ça a marché, et un message à afficher.
- Dans
ReplicatedStorage.Remotes, insère une RemoteFunction nomméeRedeemCode. - Dans StarterGui, insère un ScreenGui nommé
CodeGui, et dedans une TextBox nomméeCodeBox. Donne-lui la taille et la place que tu veux. - Ajoute le Script ci-dessous dans ServerScriptService, et le LocalScript dans
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Les codes vivent sur le serveur, où aucun joueur ne peut les lire
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 } = {}
-- Affecte avec =. OnServerInvoke est un callback, pas un événement auquel on fait 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)
Il ajoute à la stat Coins du guide du leaderboard. Les codes utilisés ne sont retenus que jusqu'au départ du joueur, donc tel quel un joueur peut revenir et réutiliser le même code. Si les pièces sont sauvegardées, ce sont des pièces gratuites à chaque retour : avant de l'utiliser dans un jeu en ligne, enregistre les codes utilisés de chaque joueur avec ses données sauvegardées dans un 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 met cette fonction en pause jusqu'au retour du callback du serveur.
-- pcall garde le LocalScript en marche si l'appel échoue.
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)
Une RemoteFunction a exactement un callback serveur. Si deux scripts règlent OnServerInvoke sur la même RemoteFunction, seul le dernier tourne.
Pourquoi InvokeClient est risqué
Une RemoteFunction marche aussi dans l'autre sens, avec InvokeClient sur le serveur et OnClientInvoke sur le client. La documentation de Roblox cite trois risques sérieux :
- Si le callback du client lève une erreur, le serveur lève l'erreur aussi.
- Si le joueur part pendant l'appel,
InvokeClientlève une erreur. - Si le client ne renvoie jamais de valeur, le script serveur attend pour toujours.
Un client modifié contrôle son propre callback, donc un tricheur peut provoquer le troisième cas exprès et bloquer ce thread du serveur aussi longtemps qu'il veut. Pour mettre à jour l'écran d'un joueur, utilise FireClient. Si le serveur a vraiment besoin d'une information venant d'un client, envoie un RemoteEvent, fais répondre le client sur un autre RemoteEvent, et traite l'absence de réponse comme un cas normal sur le serveur.
Valider chaque argument sur le serveur
Un exploiteur peut déclencher n'importe quel RemoteEvent ou appeler n'importe quelle RemoteFunction, aussi souvent qu'il veut, avec n'importe quels arguments. La seule chose qu'il ne peut pas falsifier est le premier paramètre : Roblox y met le Player qui a envoyé. Tout ce qui suit doit être vérifié avant que le serveur agisse. Cacher le remote ou vérifier dans le LocalScript ne sert à rien, parce que le tricheur contrôle son propre client.
| Vérification | La question que se pose le serveur | Exemple |
|---|---|---|
| Type | Est-ce le type que j'attends ? Une Instance, et pas une table construite pour y ressembler ? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Plage | Le nombre est-il fini et dans la plage autorisée ? Le texte a-t-il une longueur raisonnable ? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Propriété | Ce joueur possède-t-il l'objet, a-t-il l'argent, ou a-t-il le droit d'agir sur cet objet ? | L'objet est dans son inventaire ; la part est dans Paintable |
| Distance | Le personnage du joueur est-il assez près dans la copie du monde du serveur ? Laisse un peu de marge pour le lag. | À moins de 30 studs de la part |
| Fréquence | Ce joueur envoie-t-il trop vite ? | Un délai par joueur ou une réserve d'appels qui se recharge |
NaN mérite son propre avertissement. C'est un nombre, donc type(x) == "number" passe, mais toute comparaison avec lui est fausse, donc une vérification comme x < 0 or x > 100 le laisse passer directement. math.isfinite(x) rejette NaN et les deux infinis.
Connais la limite d'une vérification de distance. Chaque client contrôle la physique de son propre personnage, donc un exploiteur peut déplacer son personnage à côté de la cible avant d'envoyer. La vérification empêche quand même l'abus facile qui consiste à agir sur toute la carte depuis un seul endroit. Garde aussi les parts cibles ancrées : la documentation de sécurité de Roblox note qu'un exploiteur peut prendre la propriété réseau des parts non ancrées près de lui et les attirer vers lui, ce qui contourne une vérification de distance.
Voici les mêmes vérifications sous forme de ModuleScript que tu peux réutiliser dans chaque gestionnaire de remote.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Un vrai nombre entre min et max. Rejette NaN et l'infini, qui passent une
-- simple vérification 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 nombre entier entre min et max, pour les quantités, les index et les compteurs
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
-- Un texte avec une longueur maximale. utf8.len renvoie nil pour de l'UTF-8 invalide, que les
-- DataStores refusent.
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
-- Une Instance de la classe attendue, dans le conteneur que tu autorises.
-- Une table construite pour ressembler à une Instance échoue à la vérification 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 quand le personnage du joueur est à moins de 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
-- Une limite de fréquence par joueur. Chaque joueur peut faire `burst` appels d'un coup, et
-- regagne `perSecond` appels chaque seconde. Renvoie une fonction à appeler
-- avant de faire le travail : elle répond true (vas-y) ou false (trop vite).
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
Garde-le dans ServerScriptService. Le code qui s'y trouve n'arrive jamais chez les clients, donc personne ne peut lire tes vérifications.
Et voici le gestionnaire du schéma 1 réécrit avec lui. Remplace le contenu de PaintServer :
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" ne compte que pour le vérificateur de types strict de Luau ; ça ne change rien à l'exécution
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) -- une rafale de 4, puis 4 par seconde
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)
Le limiteur supprime l'entrée de chaque joueur quand il part, donc sa table ne grossit pas pendant toute la vie du serveur.
C'est pour les armes que ces vérifications comptent le plus : ne laisse jamais le client dire qui a été touché. Le remote du guide de l'épée ne transporte aucun argument, et le serveur trouve les cibles lui-même. Le guide du pistolet (en anglais) n'envoie qu'un point de visée, dont le serveur vérifie le type, NaN et la distance avant de lancer son propre rayon.
Les menus suivent la même règle : envoie un choix, jamais le résultat. Dans le guide des dialogues de PNJ, le client n'envoie que le numéro du bouton pressé, et le serveur cherche ce que donne cette réponse. Le menu du guide du téléporteur envoie un nom de destination, pas une position, et le serveur trouve la destination dans son propre dossier et vérifie les Wins qu'elle demande.
Ce que tu peux envoyer et ce que tu ne peux pas
Tu peux passer des nombres, des chaînes, des booléens, des types Roblox comme Vector3, CFrame, Color3 et des éléments d'Enum, des Instances que les deux côtés peuvent voir, et des tables de tout ça. Certaines valeurs changent ou disparaissent en route :
| Tu envoies | Ce qui se passe |
|---|---|
| Une fonction | L'autre côté reçoit nil |
| Une table avec une metatable | La metatable est perdue, avec tout ce que la table n'avait que grâce à elle |
| Une table qui mélange clés numériques et clés texte | Roblox dit de ne pas le faire : envoie un pur tableau ou un pur dictionnaire |
Une table contenant des valeurs nil | À éviter : Roblox déconseille nil à n'importe quel index |
| Une table avec des clés Instance, userdata ou fonction | Ces clés sont converties en chaînes |
| Une Instance que le destinataire ne peut pas voir, par exemple dans ServerStorage ou créée par un LocalScript | L'autre côté reçoit nil |
| N'importe quelle table | Le destinataire reçoit une copie, jamais la même table |
Une bonne habitude est d'envoyer des identifiants plutôt que des objets ou des valeurs : le nom d'un objet, l'index d'un choix, une part que le serveur peut retrouver et vérifier. Le serveur travaille alors à partir de ses propres données.
Pourquoi une RemoteFunction renvoie nil
Si InvokeServer te donne nil, passe ces points en revue dans l'ordre :
- Un chemin sans valeur de retour. Chaque sortie de
OnServerInvokedoit renvoyer quelque chose. Unreturnnu dans une vérification du début renvoienil. - Un return dans une fonction imbriquée. Un
returndanspcall(function() ... end), dans un gestionnaire:Connectou danstask.spawnne quitte que cette fonction intérieure. Récupère le résultat, par exemplelocal ok, data = pcall(...), puis renvoiedatadepuis le callback lui-même. - Une valeur qui ne peut pas traverser. Une fonction, ou une Instance que le client ne peut pas voir (tout ce qui est dans ServerStorage, par exemple), arrive sous forme de
nil. Avec le streaming d'instances activé, une part que le serveur vient de créer n'est peut-être pas encore arrivée chez le client quand la fonction renvoie. - Un autre script a réglé le callback. Seule la dernière affectation à
OnServerInvoketourne. Cherche le nom du remote dans tes scripts.
Si l'appel ne revient jamais, aucun script n'a encore réglé OnServerInvoke (Roblox met les appels en file d'attente jusqu'à ce qu'un script le fasse), ou le callback est bloqué, par exemple sur un WaitForChild pour quelque chose qui n'apparaît jamais.
UnreliableRemoteEvent : pour les mises à jour constantes et jetables
Un UnreliableRemoteEvent a les mêmes méthodes et événements qu'un RemoteEvent : FireServer, FireClient, FireAllClients, OnServerEvent et OnClientEvent. La différence est que Roblox ne garantit ni la livraison ni l'ordre. Un message peut être abandonné, sans être renvoyé, quand :
- il est perdu en route, ou attend trop longtemps sur un réseau encombré
- sa charge dépasse 1 000 octets
- un client envoie plus vite que la limite de débit (le surplus est abandonné, pas retardé)
- aucun gestionnaire n'est connecté quand il arrive (il est jeté, pas mis en file d'attente)
Les messages peuvent aussi arriver dans le désordre, et ils n'ont aucun ordre garanti par rapport à tes RemoteEvents ou RemoteFunctions. Utilises-en un quand seule la valeur la plus récente compte et que la prochaine mise à jour arrive une fraction de seconde plus tard : l'endroit que vise un joueur, la position d'un effet cosmétique, une valeur qui change à chaque image. Si l'ordre compte, mets un numéro de séquence ou un horodatage dans chaque message et ignore tout ce qui est plus ancien que le dernier que tu as traité.
N'en utilise jamais pour quelque chose qui doit arriver exactement une fois, comme un achat, des dégâts, une récompense ou le début d'une manche. Et valide ses arguments sur le serveur exactement comme pour un RemoteEvent.
Ordre de livraison et limites de débit
Les garanties de livraison de Roblox s'appliquent à une connexion dans un sens : du serveur vers un client, ou d'un client vers le serveur.
- Les RemoteEvents sont fiables et ordonnés. Les messages perdus sont renvoyés tant que le destinataire reste connecté, et les messages arrivent dans l'ordre où tu les as envoyés, même entre différents RemoteEvents. Si le serveur envoie A, puis B, puis A à un joueur, ce joueur reçoit A, B, A.
- L'ordre concerne le moment où les gestionnaires démarrent. Si un gestionnaire se met en attente, par exemple avec
task.waitouWaitForChild, le traitement du message suivant peut commencer avant que le premier ait fini. - Les RemoteFunctions et les RemoteEvents ne sont pas ordonnés entre eux. Si ton code dépend d'un ordre strict, envoie les messages liés par le même type de remote, ou ajoute ton propre numéro de séquence.
- Les changements de propriétés et d'attributs ne sont pas ordonnés par rapport aux remotes. Si le serveur change une propriété puis déclenche un remote, le client peut voir l'un ou l'autre en premier. Écoute le changement lui-même, par exemple avec
GetPropertyChangedSignal, plutôt que de supposer qu'il est arrivé. - Pas encore de gestionnaire. Les messages de RemoteEvent attendent en file jusqu'à ce qu'un gestionnaire se connecte. La file a des limites : une fois pleine, les messages suivants sont jetés et Output affiche une erreur
Remote event invocation discarded. - Un joueur qui part perd tous les messages qui ne lui étaient pas encore arrivés.
Limite de débit. Les messages de RemoteEvent et d'UnreliableRemoteEvent d'un client vers le serveur sont limités à environ 500 requêtes par seconde et par client, d'après la documentation au 30 septembre 2026. La limite est partagée par tous les remotes du même type, donc découper un remote chargé en dix ne l'augmente pas. Au-delà de la limite, les messages de RemoteEvent sont traités plus tard et gardent leur ordre, alors que les messages d'UnreliableRemoteEvent sont abandonnés. La limite du moteur n'empêche en rien un joueur de déclencher ton remote 50 fois par seconde, donc chaque gestionnaire qui change quelque chose a quand même besoin de sa propre limite par joueur.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent ou attribut ?
| Utilise | Pour | Exemple | Attention à |
|---|---|---|---|
| RemoteEvent | Des messages à sens unique qui doivent arriver, dans l'ordre | Client : "peins cette part". Serveur : "affiche ce message" | Valider chaque argument sur le serveur |
RemoteFunction avec InvokeServer | Le client a besoin d'une réponse avant de pouvoir continuer | Utiliser un code, confirmer un achat | L'appelant attend ; chaque chemin doit renvoyer une valeur |
RemoteFunction avec InvokeClient | Presque jamais | Utilise FireClient à la place | Un client qui plante, qui part ou qui ne répond jamais casse ou bloque l'appel du serveur |
| UnreliableRemoteEvent | Des mises à jour fréquentes où seule la dernière compte | Direction de visée, effets cosmétiques | Messages perdus ou dans le désordre ; charge limitée à 1 000 octets |
| Attribut ou objet valeur réglé par le serveur | Un état partagé qui doit toujours être visible, y compris pour les joueurs qui arrivent plus tard | Chrono de manche, phase de jeu, état ouvert d'une porte | Seuls les changements du serveur arrivent chez tout le monde ; les clients écoutent avec GetAttributeChangedSignal ou Changed |
| BindableEvent | Des scripts du même côté qui se parlent | Un script serveur qui dit à un autre qu'une manche est finie | Ne traverse pas entre serveur et client |
Pour un exemple complet de RemoteFunctions et de validation qui travaillent ensemble sur quelque chose que les joueurs paient, vois comment faire une interface de boutique. Pour la ligne des attributs, le script serveur du guide des portes règle un attribut Open sur chaque porte à chaque mouvement, donc n'importe quel LocalScript peut y réagir.
Problèmes courants
La plupart des problèmes de remotes apparaissent dans la fenêtre Output (ouvre-la depuis le menu Window ou l'onglet Script). Regarde-la d'abord, puis retrouve le symptôme ci-dessous. Le guide des erreurs de script couvre plus en détail les messages d'erreur généraux.
Infinite yield possible sur un WaitForChild pour un remote
Un script attend un remote qui n'arrive jamais. Vérifie que le nom et les majuscules correspondent exactement, et que le remote est dans ReplicatedStorage, pas dans ServerStorage ni ServerScriptService, que les clients ne peuvent pas voir.
Le serveur reçoit les mauvaises valeurs, décalées d'un cran
Le LocalScript a passé le joueur lui-même, comme dans remote:FireServer(player, 5). Roblox ajoute déjà l'expéditeur en premier paramètre, donc le serveur voit (player, player, 5). Appelle remote:FireServer(5).
Rien ne se passe quand je déclenche le remote
Vérifie que chaque appel tourne du bon côté : FireServer et InvokeServer ne marchent que depuis du code client, et FireClient, FireAllClients et InvokeClient que depuis un Script serveur. Un LocalScript ne tourne jamais dans ServerScriptService, dans ServerStorage ni directement dans Workspace ; mets-le dans StarterPlayerScripts, StarterGui, StarterCharacterScripts ou StarterPack. Cherche ensuite dans Output une erreur à l'intérieur du gestionnaire.
Remote event invocation discarded
Des messages sont arrivés pour un RemoteEvent qui n'avait aucun gestionnaire connecté, et la file s'est remplie. En général, le script du gestionnaire plante avant sa ligne :Connect, est désactivé, ou reste bloqué à attendre quelque chose qui ne charge jamais. Connecte les gestionnaires près du haut du script.
Ça marche pour moi, mais les autres joueurs ne voient pas le changement
Le changement a été fait sur le client, dans un LocalScript ou un gestionnaire OnClientEvent. Fais-le plutôt dans le gestionnaire OnServerEvent du serveur.
InvokeServer ne revient jamais
Soit aucun script n'a réglé OnServerInvoke (Roblox met les appels en file d'attente jusqu'à ce qu'un script le fasse), soit le callback est bloqué sur quelque chose qui attend, comme un WaitForChild ou une requête de DataStore. Ajoute un print au début et à la fin du callback pour voir où il s'arrête.
Le faire avec RoCode
Tu peux aussi demander à RoCode de mettre ça en place dans le jeu que tu as ouvert. RoCode est un agent IA qui travaille à travers un plugin Roblox Studio, donc il crée les remotes et les scripts dans ton Explorer au lieu de te donner du code à coller.
Permets aux joueurs de cliquer sur les parts du dossier Paintable pour les peindre. Utilise un RemoteEvent, et garde les vérifications sur le serveur : seulement les parts de ce dossier, à moins de 30 studs, et pas plus de quelques peintures par seconde.
- Parcourt en général le jeu d'abord, avec Search Game et Search Scripts, pour trouver un dossier Remotes ou un gestionnaire existant, et utilise tes dossiers quand ils sont là
- Crée le RemoteEvent dans ReplicatedStorage avec Create Instance, et écrit le Script serveur et le LocalScript avec Create Script
- Vérifie la compilation de chaque script avec Check Script dans Studio avant de finir. Ça attrape les erreurs de compilation, pas les bugs de logique : il ne vérifie pas les types, ne fait pas de lint et ne lance pas ton code
- Envoie ses changements par lots, et chaque lot est un point d'annulation dans l'historique de Studio
Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.11 ou plus récent il peut contrôler un personnage de test, mais il ne clique pas sur les parts dans la vue 3D. Appuie toi-même sur Play et essaie de casser les vérifications, par exemple en peignant depuis l'autre bout de la carte. Si quelque chose plante, Check Output peut lire les lignes Server et Client de ton dernier test. La plupart des systèmes de jeu se parlent par des remotes comme ceux-ci, donc tu les retrouveras quand tu construis un jeu système par système avec RoCode. Comment RoCode se connecte à Studio.
Questions fréquentes
Que veut dire sécuriser la frontière client-serveur sur Roblox ?
C'est le nom de la page de la documentation Roblox sur la sécurité des remotes (Securing the client-server boundary), et l'idée est simple : tout ce qu'un client envoie par un RemoteEvent ou une RemoteFunction peut venir d'un exploiteur, donc le serveur le vérifie avant d'agir. Vérifie le type de chaque argument, garde les nombres dans une plage raisonnable, vérifie que le joueur a le droit de le faire à ce moment-là, et limite la fréquence d'envoi de chaque joueur. La liste de vérifications plus haut montre chacun de ces points en code.
Les RemoteFunctions sont-elles sûres ?
InvokeServer est aussi sûr que ton callback serveur : valide ses arguments et limite sa fréquence comme pour n'importe quel RemoteEvent. InvokeClient est le sens risqué, parce qu'un client qui plante, qui part ou qui ne répond jamais casse ou bloque l'appel du serveur.
Les exploiteurs peuvent-ils voir et déclencher mes remotes ?
Oui. Tout ce qui est dans ReplicatedStorage arrive chez chaque client, et un client modifié peut déclencher n'importe quel remote avec n'importe quels arguments. Renommer ou cacher les remotes ne les rend pas sûrs ; vérifier chaque argument sur le serveur, si.
Un client peut-il envoyer un RemoteEvent à un autre client ?
Pas directement. Envoie-le au serveur, vérifie-le là, puis utilise FireClient ou FireAllClients.
À quelle fréquence puis-je déclencher un RemoteEvent ?
Roblox documente une limite d'environ 500 requêtes par seconde et par client pour les messages de RemoteEvent et d'UnreliableRemoteEvent envoyés au serveur, partagée par tous les remotes du même type. Reste bien en dessous, et donne à chaque gestionnaire sa propre limite par joueur.
FireAllClients atteint-il les joueurs qui arrivent plus tard ?
Non. Il atteint les joueurs connectés à ce moment-là. Pour un état dont les retardataires ont besoin, règle un attribut ou un objet valeur sur le serveur.
Quelle est la différence entre un RemoteEvent et un BindableEvent ?
Un RemoteEvent traverse entre serveur et client. Un BindableEvent relie des scripts du même côté, comme deux scripts serveur.
Sources et lectures
- Roblox Creator Docs : Remote events and callbacks (en anglais). FireServer, FireClient, InvokeServer, les risques d'InvokeClient, les limites des arguments et les garanties de livraison
- Roblox Creator Docs : Securing the client-server boundary (en anglais). les couches de validation, NaN, la limitation de fréquence, les relais de client à client
- Roblox Creator Docs : Security and cheat mitigation tactics (en anglais). ce que peut faire un client modifié, et l'autorité du serveur
- Roblox Creator Docs : Network ownership, movement validation, and physics (en anglais). pourquoi un client contrôle son propre personnage, et les limites des vérifications de distance
- Roblox Engine API : RemoteEvent (en anglais). la limite de débit et l'erreur invocation discarded
- Roblox Engine API : RemoteFunction (en anglais). OnServerInvoke, les avertissements sur InvokeClient et les précautions avec le streaming
- Roblox Engine API : UnreliableRemoteEvent (en anglais). la limite de charge de 1 000 octets
- Roblox Creator Docs : Properties and attributes (en anglais). l'ordre de réplication entre les changements de propriétés et les remote events
Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 12 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.