Tutoriel · Bases du scripting

Les RemoteEvents sur Roblox : du client au serveur et retour

Un LocalScript ne peut pas changer ce que voient les autres joueurs, et un Script serveur ne peut pas toucher à l'écran d'un joueur. Les RemoteEvents transportent les messages entre les deux. Ce guide construit les trois schémas que tu utiliseras le plus, une RemoteFunction qui renvoie une réponse, et les vérifications côté serveur qui empêchent un client modifié d'en abuser.

Mis à jour le 12 novembre 202621 min de lectureÉcrit par

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 (InvokeServer et OnServerInvoke) que quand le client a besoin d'une réponse. Évite InvokeClient : 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
  1. Pourquoi les remotes
  2. Préparer les remotes
  3. 1. Client vers serveur
  4. 2. Serveur vers un client
  5. 3. Serveur vers tous
  6. RemoteFunctions
  7. Liste de vérifications
  8. Ce qui ne s'envoie pas
  9. Renvoie nil ?
  10. UnreliableRemoteEvent
  11. Ordre et limites
  12. Lequel utiliser
  13. Problèmes courants
  14. Avec RoCode
  15. Questions fréquentes
  16. Sources et lectures

Pourquoi les RemoteEvents existent

Illustration animéeChaque clic demande au serveur de peindre la part, donc les écrans des deux joueurs affichent la nouvelle couleur.

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.
Quel appel déclenche quel événement
SensL'expéditeur appelleLe destinataire se connecte àLe destinataire reçoit
Du client au serveurremote:FireServer(...) dans un LocalScriptremote.OnServerEvent dans un ScriptLe Player qui a envoyé, puis tes arguments
Du serveur à un clientremote:FireClient(player, ...) dans un Scriptremote.OnClientEvent dans un LocalScriptTes arguments seulement
Du serveur à tous les clientsremote:FireAllClients(...) dans un Scriptremote.OnClientEvent dans un LocalScriptTes arguments seulement
Le client demande, le serveur répondremoteFunction: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.

  1. Dans l'Explorer, survole ReplicatedStorage, clique sur le bouton + et insère un Folder. Nomme-le Remotes.
  2. Survole Remotes, clique sur + et insère un RemoteEvent. Renomme-le pour décrire son rôle, par exemple PaintRequest.
  3. Recommence pour chaque remote. Ce guide utilise deux RemoteEvents (PaintRequest et Notify) et une RemoteFunction (RedeemCode).
L'Explorer : tout ce que ce guide ajoute, partie par partie
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.

  1. Dans Workspace, insère un Folder nommé Paintable et mets-y quelques Parts ancrées.
  2. Vérifie que ReplicatedStorage.Remotes contient un RemoteEvent nommé PaintRequest.
  3. Insère un Script dans ServerScriptService nommé PaintServer, et un LocalScript dans StarterPlayer, StarterPlayerScripts nommé PaintClient, avec le code ci-dessous.
Script dans ServerScriptService nommé 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")

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

LocalScript dans StarterPlayerScripts nommé 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 -- 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.

Script dans ServerScriptService nommé WelcomeServer
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
LocalScript dans StarterPlayerScripts nommé NotifyClient
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.

Script dans ServerScriptService nommé 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 -- 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.

  1. Dans ReplicatedStorage.Remotes, insère une RemoteFunction nommée RedeemCode.
  2. Dans StarterGui, insère un ScreenGui nommé CodeGui, et dedans une TextBox nommée CodeBox. Donne-lui la taille et la place que tu veux.
  3. Ajoute le Script ci-dessous dans ServerScriptService, et le LocalScript dans CodeBox.
Script dans ServerScriptService nommé RedeemServer
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.

LocalScript dans la TextBox CodeBox nommé 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 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, InvokeClient lè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.

La liste de vérifications côté serveur
VérificationLa question que se pose le serveurExemple
TypeEst-ce le type que j'attends ? Une Instance, et pas une table construite pour y ressembler ?typeof(part) == "Instance" and part:IsA("BasePart")
PlageLe 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
DistanceLe 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équenceCe 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.

ModuleScript dans ServerScriptService nommé RemoteGuard
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 :

Script dans ServerScriptService nommé 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 :

Les arguments qui n'arrivent pas tels qu'ils ont été envoyés
Tu envoiesCe qui se passe
Une fonctionL'autre côté reçoit nil
Une table avec une metatableLa 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 texteRoblox 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 fonctionCes 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 LocalScriptL'autre côté reçoit nil
N'importe quelle tableLe 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 :

  1. Un chemin sans valeur de retour. Chaque sortie de OnServerInvoke doit renvoyer quelque chose. Un return nu dans une vérification du début renvoie nil.
  2. Un return dans une fonction imbriquée. Un return dans pcall(function() ... end), dans un gestionnaire :Connect ou dans task.spawn ne quitte que cette fonction intérieure. Récupère le résultat, par exemple local ok, data = pcall(...), puis renvoie data depuis le callback lui-même.
  3. 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.
  4. Un autre script a réglé le callback. Seule la dernière affectation à OnServerInvoke tourne. 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.wait ou WaitForChild, 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 ?

Choisir comment le client et le serveur se parlent
UtilisePourExempleAttention à
RemoteEventDes messages à sens unique qui doivent arriver, dans l'ordreClient : "peins cette part". Serveur : "affiche ce message"Valider chaque argument sur le serveur
RemoteFunction avec InvokeServerLe client a besoin d'une réponse avant de pouvoir continuerUtiliser un code, confirmer un achatL'appelant attend ; chaque chemin doit renvoyer une valeur
RemoteFunction avec InvokeClientPresque jamaisUtilise FireClient à la placeUn client qui plante, qui part ou qui ne répond jamais casse ou bloque l'appel du serveur
UnreliableRemoteEventDes mises à jour fréquentes où seule la dernière compteDirection de visée, effets cosmétiquesMessages perdus ou dans le désordre ; charge limitée à 1 000 octets
Attribut ou objet valeur réglé par le serveurUn état partagé qui doit toujours être visible, y compris pour les joueurs qui arrivent plus tardChrono de manche, phase de jeu, état ouvert d'une porteSeuls les changements du serveur arrivent chez tout le monde ; les clients écoutent avec GetAttributeChangedSignal ou Changed
BindableEventDes scripts du même côté qui se parlentUn script serveur qui dit à un autre qu'une manche est finieNe 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.

Tu écris

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.

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

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.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.