La respuesta corta
Un RemoteEvent es un objeto, que normalmente se guarda en ReplicatedStorage, que envía mensajes a través de la frontera entre cliente y servidor. Un LocalScript llama a FireServer y el servidor lo recibe en OnServerEvent, con el Player que lo envió añadido como primer argumento. El servidor llama a FireClient(player, ...) o FireAllClients(...), y los LocalScripts lo reciben en OnClientEvent.
- Usa una RemoteFunction (
InvokeServeryOnServerInvoke) solo cuando el cliente necesita una respuesta. EvitaInvokeClient: un cliente que da error, se va o nunca responde rompe la llamada del servidor. - Nunca confíes en lo que envía un cliente. En el servidor, comprueba el tipo, el rango y la propiedad de cada argumento, la distancia del jugador y con qué frecuencia dispara.
- Las funciones, las metatablas y los objetos que el otro lado no puede ver no sobreviven al viaje. Un UnreliableRemoteEvent puede perder o reordenar mensajes, y descarta cualquier carga de más de 1000 bytes.
En esta página
Por qué existen los RemoteEvents
Todo juego de Roblox se ejecuta como un servidor más un cliente por jugador. El servidor es la autoridad: un objeto nuevo o un cambio de propiedad solo llega a todos los jugadores cuando lo hace el servidor. Un cambio hecho en un LocalScript se queda en ese dispositivo, con algunas excepciones como el personaje del propio jugador, cuyo movimiento controla su cliente. Así que cuando un clic o una tecla debe cambiar el mundo compartido, el cliente tiene que pedírselo al servidor, y cuando el servidor quiere que la pantalla de un jugador reaccione, tiene que decírselo a ese cliente. Si la diferencia entre Script y LocalScript es nueva para ti, lee primero Script vs LocalScript vs ModuleScript (en inglés). Si lo nuevo es programar, empieza por cómo programar en Roblox Studio.
Roblox te da tres objetos para cruzar esa frontera:
- RemoteEvent: un mensaje de un solo sentido. El que lo envía sigue de inmediato.
- RemoteFunction: una petición que espera una respuesta. El que llama se pausa hasta que el otro lado devuelve un valor.
- UnreliableRemoteEvent: un mensaje de un solo sentido que se puede perder o llegar desordenado, a cambio de menos carga de red. Sirve para datos que cambian todo el tiempo.
| Dirección | El emisor llama a | El receptor se conecta a | El receptor recibe |
|---|---|---|---|
| Del cliente al servidor | remote:FireServer(...) en un LocalScript | remote.OnServerEvent en un Script | El Player que disparó, y luego tus argumentos |
| Del servidor a un cliente | remote:FireClient(player, ...) en un Script | remote.OnClientEvent en un LocalScript | Solo tus argumentos |
| Del servidor a todos los clientes | remote:FireAllClients(...) en un Script | remote.OnClientEvent en un LocalScript | Solo tus argumentos |
| El cliente pregunta, el servidor responde | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | El Player, y luego tus argumentos. El que llama recibe lo que devuelva la función |
Los clientes no pueden enviarse mensajes directamente. Para pasar algo de un jugador a los demás, dispáralo al servidor, compruébalo ahí y deja que el servidor lo reenvíe con FireClient o FireAllClients. La guía de seguridad de Roblox dice que aquí el servidor actúa como un portero, nunca como un simple repetidor.
Dónde poner tus remotes
Un remote tiene que estar donde lo puedan ver tanto el servidor como los clientes. El lugar habitual es ReplicatedStorage; la documentación de Roblox indica que Workspace o una Tool también pueden ser correctos en algunos casos. ServerStorage y ServerScriptService son solo del servidor, así que un LocalScript que espera un remote ahí espera para siempre.
- En el Explorer, pasa el ratón sobre ReplicatedStorage, haz clic en el botón + e inserta una Folder. Llámala
Remotes. - Pasa el ratón sobre
Remotes, haz clic en + e inserta un RemoteEvent. Cámbiale el nombre para que describa su propósito, por ejemploPaintRequest. - Repite para cada remote. Esta guía usa dos RemoteEvents (
PaintRequestyNotify) y 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
Los scripts de esta guía buscan los remotes con WaitForChild. Devuelve el remote al instante cuando ya está ahí y espera cuando no, por ejemplo cuando un script del servidor crea los remotes mientras el juego se ejecuta. Usa un remote por cada tipo de petición: así cada manejador del servidor comprueba una sola forma de argumentos, que es mucho más fácil de hacer bien que un único remote que hace de todo.
Patrón 1: del cliente al servidor, comprobado por el servidor
El trabajo más común: el jugador hace algo en su pantalla y el servidor decide qué pasa. Aquí el jugador pulsa Q para elegir uno de cuatro colores y hace clic o toca una parte para pintarla. Todos ven el color nuevo, porque el que pinta es el servidor.
El cliente envía dos cosas: qué parte, y un número de color. Nunca envía el color en sí, y en otros juegos nunca debe enviar un precio, una recompensa o una cantidad de daño. Un cliente modificado puede enviar cualquier cosa, así que el servidor guarda los datos reales (aquí, la paleta) y trata los argumentos como una petición que hay que comprobar.
- En Workspace, inserta una Folder llamada
Paintabley pon dentro algunas Parts ancladas. - Comprueba que
ReplicatedStorage.Remotestiene un RemoteEvent llamadoPaintRequest. - Inserta un Script en ServerScriptService llamado
PaintServer, y un LocalScript en StarterPlayer, StarterPlayerScripts llamadoPaintClient, con el código de abajo.
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")
-- El servidor es el dueño de los colores. El cliente solo envía un número que elige 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 -- studs entre el personaje y la parte
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- El primer parámetro siempre es el jugador que disparó el evento. Lo rellena Roblox,
-- así que es de fiar. Todo lo que viene después llegó del cliente y no lo es.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Tipo: una parte de verdad, no una tabla que se hace pasar por una
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Rango: un número entero del 1 al 4. NaN e infinito también fallan aquí.
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. Objetivo permitido: solo partes de la carpeta Paintable, nada más del juego
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Distancia: el personaje del jugador debe estar cerca de la 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. Límite de frecuencia: una pintada por jugador cada cuarto de segundo
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)
Cada comprobación que falla simplemente hace return. No hace falta decirle a un cliente tramposo por qué se le rechazó.
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 -- el servidor tiene los colores reales
local selectedColour = 1
-- Deja que el rayo golpee solo partes dentro de la carpeta 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 tecla o el clic fue al chat o a un botón
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
-- Pide, no ordenes: el servidor decide si se pinta
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed es true cuando el motor ya actuó sobre la entrada, normalmente en la UI: un clic en un botón, o teclas escritas en un cuadro de texto como la barra del chat. Comprobarlo hace que escribir una Q en un mensaje no cambie el color.
Patrón 2: del servidor a un cliente
El servidor envía un mensaje a un jugador con FireClient. El primer argumento es el Player al que se envía, y el manejador del cliente recibe solo los argumentos que van después. Úsalo para todo lo personal: una notificación, una ventana de recompensa, un sonido que solo ese jugador debe oír. La guía de cinemáticas es un ejemplo más grande: el servidor decide cuándo un jugador ve una cinemática y envía sus tomas a ese jugador con FireClient, y su dispositivo mueve la cámara.
Este par muestra un mensaje de bienvenida cuando entra un jugador. El LocalScript construye su propio cartel pequeño, así que no hay ninguna GUI que preparar.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local function welcome(player: Player)
-- El primer argumento elige qué cliente lo recibe. Nadie más ve esto.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- En Studio puedes entrar antes de que este script se conecte, así que saluda a quien ya esté aquí
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 pequeño cartel en la parte de arriba de la pantalla, hecho con código
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
-- Aquí no hay parámetro de jugador: el servidor ya eligió quién lo recibe
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 -- ocúltalo a menos que lo haya reemplazado un mensaje más nuevo
label.Visible = false
end
end)
end)
El servidor dispara en PlayerAdded, lo cual puede pasar antes de que este LocalScript haya conectado su manejador. No hay problema: Roblox pone en cola los mensajes de RemoteEvent que llegan antes de que exista un manejador y los entrega, en orden, cuando se conecta uno.
El cliente no necesita protegerse del servidor: solo el código del servidor puede disparar OnClientEvent. La anotación message: string es para el verificador de tipos; no es una comprobación en tiempo de ejecución.
Patrón 3: del servidor a todos los clientes
FireAllClients envía el mismo mensaje a todos los jugadores conectados. No lleva argumento Player, y cada cliente lo recibe en el mismo OnClientEvent de antes, así que el script NotifyClient del patrón 2 ya lo muestra.
Este Script anuncia a todos cuando un jugador toca por primera vez una línea de meta. Añade a Workspace una Part anclada llamada FinishLine, y luego añade el Script a 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 -- no es un jugador, o ya se anunció
end
finished[player] = true
-- Cada cliente conectado ejecuta su manejador de OnClientEvent con este texto
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
Un exploiter puede disparar Touched para su propio personaje desde cualquier distancia, lo cual es inofensivo para un anuncio que se muestra una vez por jugador. Si más adelante das una recompensa por llegar a la meta, añade comprobaciones en el servidor antes de pagarla, como un tiempo mínimo desde que empezó la ronda.
FireAllClients llega solo a los jugadores conectados en ese momento. Alguien que entra un segundo después nunca ve el mensaje. Eso está bien para momentos puntuales, como un anuncio, un efecto de explosión o un sonido, pero mal para un estado como el temporizador de una ronda o la fase actual del juego. Para el estado, pon un atributo en el servidor, por ejemplo ReplicatedStorage:SetAttribute("TimeLeft", 30), y léelo en el cliente con GetAttribute y GetAttributeChangedSignal("TimeLeft"). Los atributos se replican a todos los clientes, incluidos los jugadores que entran más tarde.
RemoteFunction: cuando el cliente necesita una respuesta
Un RemoteEvent se dispara y se olvida. Una RemoteFunction hace esperar al que llama: InvokeServer pausa el código que la llamó hasta que la función OnServerInvoke del servidor devuelve un valor, y luego entrega lo que haya devuelto. Usa una cuando el cliente no puede seguir sin la respuesta, como "¿ese código era válido?". Cuando no necesitas respuesta, Roblox recomienda un RemoteEvent, porque no espera.
Ejemplo: un cuadro donde los jugadores escriben un código de recompensa. El servidor guarda los códigos, comprueba el texto y devuelve dos valores: si funcionó, y un mensaje para mostrar.
- En
ReplicatedStorage.Remotes, inserta una RemoteFunction llamadaRedeemCode. - En StarterGui, inserta un ScreenGui llamado
CodeGui, y dentro un TextBox llamadoCodeBox. Dale el tamaño y la posición que quieras. - Añade el Script de abajo a ServerScriptService, y el LocalScript dentro de
CodeBox.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- Los códigos viven en el servidor, donde ningún jugador puede leerlos
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 } = {}
-- Asigna con =. OnServerInvoke es un callback, no un evento al que te conectas con 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)
Suma a la estadística Coins de la guía del leaderboard. Los códigos usados se recuerdan solo hasta que el jugador se va, así que, tal como está escrito, un jugador puede volver a entrar y canjear el mismo código otra vez. Si las monedas se guardan, eso son monedas gratis en cada reingreso: antes de usarlo en un juego en vivo, guarda los códigos usados de cada jugador con sus datos guardados en un data store.
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 pausa esta función hasta que el callback del servidor devuelve un valor.
-- pcall mantiene el LocalScript en marcha si la llamada falla.
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 tiene exactamente un callback del servidor. Si dos scripts asignan OnServerInvoke en la misma RemoteFunction, solo se ejecuta el último.
Por qué InvokeClient es arriesgado
Una RemoteFunction también funciona en el otro sentido, con InvokeClient en el servidor y OnClientInvoke en el cliente. La documentación de Roblox enumera tres riesgos serios:
- Si el callback del cliente lanza un error, el servidor también lanza el error.
- Si el jugador se va mientras se le está invocando,
InvokeClientlanza un error. - Si el cliente nunca devuelve un valor, el script del servidor espera para siempre.
Un cliente modificado controla su propio callback, así que un tramposo puede provocar el tercero a propósito y retener ese hilo del servidor todo el tiempo que quiera. Para actualizar la pantalla de un jugador, usa FireClient. Si el servidor de verdad necesita información de un cliente, dispara un RemoteEvent, haz que el cliente responda por otro RemoteEvent y trata la falta de respuesta como un caso normal en el servidor.
Valida cada argumento en el servidor
Un exploiter puede disparar cualquier RemoteEvent o invocar cualquier RemoteFunction, tantas veces como quiera y con cualquier argumento. Lo único que no puede falsificar es el primer parámetro: Roblox rellena el Player que lo envió. Todo lo que viene después hay que comprobarlo antes de que el servidor actúe. Esconder el remote o comprobar en el LocalScript no ayuda, porque el tramposo controla su propio cliente.
| Comprobación | La pregunta que se hace el servidor | Ejemplo |
|---|---|---|
| Tipo | ¿Es del tipo que espero? ¿Una Instance, no una tabla hecha para parecerlo? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Rango | ¿El número es finito y está dentro del rango permitido? ¿El texto tiene una longitud razonable? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Propiedad | ¿Este jugador es dueño del objeto, tiene el dinero o tiene derecho a actuar sobre este objeto? | El objeto está en su inventario; la parte está dentro de Paintable |
| Distancia | ¿El personaje del jugador está lo bastante cerca en la copia del mundo del servidor? Deja algo de margen por el lag. | A menos de 30 studs de la parte |
| Frecuencia | ¿Este jugador está enviando demasiado rápido? | Un tiempo de espera por jugador o una reserva de llamadas que se recarga |
NaN merece su propia advertencia. Es un número, así que type(x) == "number" pasa, pero toda comparación con él es falsa, así que una comprobación como x < 0 or x > 100 lo deja pasar directamente. math.isfinite(x) rechaza NaN y los dos infinitos.
Conoce el límite de una comprobación de distancia. Cada cliente controla la física de su propio personaje, así que un exploiter puede mover su personaje junto al objetivo antes de disparar. Aun así, la comprobación impide el abuso fácil de actuar sobre todo el mapa desde un solo punto. Mantén también ancladas las partes objetivo: la documentación de seguridad de Roblox indica que un exploiter puede tomar la propiedad de red de las partes sin anclar que tiene cerca y acercarlas, lo cual esquiva una comprobación de distancia.
Aquí están las mismas comprobaciones como un ModuleScript que puedes reutilizar en cada manejador de remote.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Un número real entre min y max. Rechaza NaN e infinito, que pasan una
-- comprobación simple de 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 número entero entre min y max, para conteos, índices y cantidades
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
-- Texto con un límite de longitud. utf8.len devuelve nil con UTF-8 no válido, que los
-- data stores rechazan.
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
-- Una Instance de la clase esperada, dentro del contenedor que permites.
-- Una tabla hecha para parecer una Instance falla la comprobación de 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 cuando el personaje del jugador está a maxDistance studs o menos 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
-- Un límite de frecuencia por jugador. Cada jugador puede hacer `burst` llamadas de golpe, y
-- recupera `perSecond` llamadas cada segundo. Devuelve una función que se llama
-- antes de hacer el trabajo: responde true (adelante) o false (demasiado rápido).
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
Déjalo en ServerScriptService. El código de ahí nunca llega a los clientes, así que nadie puede leer tus comprobaciones.
Y aquí está el manejador del patrón 1 reescrito con él. Reemplaza el contenido de PaintServer:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" solo le importa al verificador de tipos estricto de Luau; no cambia nada al ejecutar
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) -- una ráfaga de 4, luego 4 por segundo
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)
El limitador quita la entrada de cada jugador cuando se va, así que su tabla no crece durante toda la vida del servidor.
Las armas son donde más importan estas comprobaciones: nunca dejes que el cliente diga a quién golpeó. El remote de la guía de la espada no lleva ningún argumento, y el servidor encuentra los objetivos por su cuenta. La guía del arma de fuego (en inglés) envía solo un punto de mira, y el servidor comprueba su tipo, NaN y la distancia antes de lanzar su propio rayo.
Los menús siguen la misma regla: envía una elección, nunca el resultado. En la guía de diálogo con NPC el cliente envía solo el número del botón pulsado, y el servidor busca qué da esa respuesta. El menú de la guía del teletransportador envía el nombre de un punto, no una posición, y el servidor busca el punto en su propia carpeta y comprueba las Wins que necesita.
Qué puedes y qué no puedes enviar
Puedes pasar números, strings, booleanos, tipos de Roblox como Vector3, CFrame, Color3 y elementos de Enum, Instances que los dos lados pueden ver, y tablas de todo eso. Algunos valores cambian o desaparecen por el camino:
| Envías | Qué pasa |
|---|---|
| Una función | El otro lado recibe nil |
| Una tabla con metatabla | La metatabla se pierde, junto con todo lo que la tabla solo tenía a través de ella |
| Una tabla que mezcla claves numéricas y claves de texto | Roblox dice que no lo hagas: envía un array puro o un diccionario puro |
Una tabla con valores nil dentro | Evítalo: Roblox desaconseja nil en cualquier índice |
| Una tabla con claves que son Instance, userdata o función | Esas claves se convierten en strings |
| Una Instance que el receptor no puede ver, como una en ServerStorage o una creada por un LocalScript | El otro lado recibe nil |
| Cualquier tabla | El receptor recibe una copia, nunca la misma tabla |
Una buena costumbre es enviar identificadores y no objetos o valores: el nombre de un objeto, el índice de una opción, una parte que el servidor puede buscar y comprobar. Así el servidor trabaja con sus propios datos.
Por qué una RemoteFunction devuelve nil
Si InvokeServer te da nil, revisa esto en orden:
- Un camino sin valor de retorno. Toda salida de
OnServerInvokedebe devolver algo. Unreturna secas en una comprobación temprana devuelvenil. - Un return dentro de una función anidada. Un
returndentro depcall(function() ... end), de un manejador de:Connecto detask.spawnsolo sale de esa función interna. Captura el resultado, por ejemplolocal ok, data = pcall(...), y luego devuelvedatadesde el propio callback. - Un valor que no puede cruzar. Una función, o una Instance que el cliente no puede ver (cualquier cosa en ServerStorage, por ejemplo), llega como
nil. Con el streaming de instancias activado, puede que una parte que el servidor acaba de crear todavía no haya llegado al cliente cuando la función devuelve el valor. - Otro script asignó el callback. Solo se ejecuta la última asignación a
OnServerInvoke. Busca el nombre del remote en tus scripts.
Si la llamada nunca vuelve, es que ningún script ha asignado OnServerInvoke todavía (Roblox pone las llamadas en cola hasta que alguno lo hace), o el callback está atascado, por ejemplo en un WaitForChild de algo que nunca aparece.
UnreliableRemoteEvent: para actualizaciones constantes y desechables
Un UnreliableRemoteEvent tiene los mismos métodos y eventos que un RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent y OnClientEvent. La diferencia es que Roblox no garantiza ni la entrega ni el orden. Un mensaje se puede perder, sin que se reenvíe, cuando:
- se pierde en el camino, o espera demasiado en una red congestionada
- su carga es mayor de 1000 bytes
- un cliente dispara más rápido que el límite de frecuencia (el exceso se descarta, no se retrasa)
- no hay ningún manejador conectado cuando llega (se descarta, no se pone en cola)
Los mensajes también pueden llegar desordenados, y no tienen ninguna relación de orden con tus RemoteEvents o RemoteFunctions. Usa uno cuando solo importa el valor más nuevo y la siguiente actualización llega en una fracción de segundo: hacia dónde apunta un jugador, la posición de un efecto cosmético, un valor que cambia en cada frame. Si el orden importa, pon un número de secuencia o una marca de tiempo en cada mensaje e ignora todo lo que sea más viejo que el último que manejaste.
Nunca uses uno para algo que debe pasar exactamente una vez, como una compra, daño, una recompensa o el inicio de una ronda. Y valida sus argumentos en el servidor igual que lo harías con un RemoteEvent.
Orden de entrega y límites de frecuencia
Las garantías de entrega de Roblox se aplican a una conexión en un sentido: el servidor hacia un cliente, o un cliente hacia el servidor.
- Los RemoteEvents son fiables y ordenados. Los mensajes perdidos se reenvían mientras el destinatario siga conectado, y los mensajes llegan en el orden en que los disparaste, incluso entre RemoteEvents distintos. Si el servidor dispara A, luego B y luego A a un jugador, ese jugador recibe A, B, A.
- El orden se refiere a cuándo empiezan los manejadores. Si un manejador cede el control, por ejemplo con
task.waitoWaitForChild, el siguiente mensaje puede empezar a manejarse antes de que termine el primero. - Las RemoteFunctions y los RemoteEvents no están ordenados entre sí. Si tu código depende de un orden estricto, envía los mensajes relacionados por el mismo tipo de remote, o añade tu propio número de secuencia.
- Los cambios de propiedades y atributos no están ordenados respecto a los remotes. Si el servidor cambia una propiedad y luego dispara un remote, el cliente puede ver cualquiera de los dos primero. Escucha el cambio en sí, por ejemplo con
GetPropertyChangedSignal, en vez de suponer que ya llegó. - Todavía no hay manejador. Los mensajes de RemoteEvent se ponen en cola hasta que se conecta un manejador. La cola tiene límites: cuando se llena, los mensajes siguientes se descartan y Output muestra un error
Remote event invocation discarded. - Un jugador que se va pierde los mensajes que todavía no le habían llegado.
Límite de frecuencia. Los mensajes de RemoteEvent y UnreliableRemoteEvent de un cliente al servidor se limitan a unas 500 peticiones por segundo por cliente, según la documentación al 30 de septiembre de 2026. El límite lo comparten todos los remotes del mismo tipo, así que dividir un remote muy usado en diez no lo sube. Pasado el límite, los mensajes de RemoteEvent se procesan más tarde y conservan su orden, mientras que los de UnreliableRemoteEvent se descartan. El límite del motor no hace nada para impedir que un jugador dispare tu remote 50 veces por segundo, así que cada manejador que cambia algo sigue necesitando su propio límite por jugador.
¿RemoteEvent, RemoteFunction, UnreliableRemoteEvent o atributo?
| Usa | Para | Ejemplo | Ten cuidado con |
|---|---|---|---|
| RemoteEvent | Mensajes de un solo sentido que deben llegar, en orden | Cliente: "pinta esta parte". Servidor: "muestra este aviso" | Valida cada argumento en el servidor |
RemoteFunction con InvokeServer | El cliente necesita una respuesta antes de poder seguir | Canjear un código, confirmar una compra | El que llama espera; todos los caminos deben devolver un valor |
RemoteFunction con InvokeClient | Casi nunca | Usa FireClient en su lugar | Un cliente que da error, se va o nunca responde rompe o congela la llamada del servidor |
| UnreliableRemoteEvent | Actualizaciones frecuentes donde solo importa la última | Dirección de la mira, efectos cosméticos | Mensajes perdidos o desordenados; límite de carga de 1000 bytes |
| Atributo u objeto de valor puesto por el servidor | Estado compartido que siempre debe estar visible, también para los jugadores que entran más tarde | Temporizador de ronda, fase del juego, si una puerta está abierta | Solo los cambios del servidor llegan a todos; los clientes escuchan con GetAttributeChangedSignal o Changed |
| BindableEvent | Scripts del mismo lado que hablan entre sí | Un script del servidor que avisa a otro de que terminó una ronda | No cruza entre servidor y cliente |
Para un ejemplo completo de RemoteFunctions y validación trabajando juntas en algo por lo que pagan los jugadores, consulta cómo hacer una GUI de tienda. Para la fila del atributo, el script del servidor de la guía de la puerta pone un atributo Open en cada puerta cada vez que se mueve, así que cualquier LocalScript puede reaccionar a él.
Errores comunes y soluciones
La mayoría de los problemas con remotes aparecen en la ventana Output (ábrela desde el menú Window o la pestaña Script). Revísala primero y luego busca el síntoma abajo. La guía de errores de scripts cubre los mensajes de error generales con más detalle.
Infinite yield possible en un WaitForChild de un remote
Un script está esperando un remote que nunca llega. Comprueba que el nombre y las mayúsculas coinciden exactamente, y que el remote está en ReplicatedStorage, no en ServerStorage ni en ServerScriptService, que los clientes no pueden ver.
El servidor recibe valores equivocados, desplazados un lugar
El LocalScript pasó al propio jugador, como en remote:FireServer(player, 5). Roblox ya añade al emisor como primer parámetro, así que el servidor ve (player, player, 5). Llama a remote:FireServer(5).
No pasa nada cuando disparo el remote
Comprueba que cada llamada se ejecuta en el lado correcto: FireServer e InvokeServer solo funcionan desde código del cliente, y FireClient, FireAllClients e InvokeClient solo desde un Script del servidor. Un LocalScript nunca se ejecuta en ServerScriptService, en ServerStorage ni directamente en Workspace; ponlo en StarterPlayerScripts, StarterGui, StarterCharacterScripts o StarterPack. Luego busca en Output un error dentro del manejador.
Remote event invocation discarded
Llegaron mensajes a un RemoteEvent que no tenía ningún manejador conectado, y la cola se llenó. Normalmente el script del manejador da error antes de su línea de :Connect, está desactivado o está atascado esperando algo que nunca carga. Conecta los manejadores cerca del principio del script.
A mí me funciona, pero los demás jugadores no ven el cambio
El cambio se hizo en el cliente, en un LocalScript o en un manejador de OnClientEvent. Hazlo en el manejador de OnServerEvent del servidor.
InvokeServer nunca vuelve
O ningún script ha asignado OnServerInvoke (Roblox pone las llamadas en cola hasta que alguno lo hace), o el callback está atascado en algo que cede el control, como un WaitForChild o una petición a un data store. Añade un print al principio y al final del callback para ver dónde se detiene.
Constrúyelo con RoCode
También puedes hacer que RoCode monte esto en el place que tienes abierto. RoCode es un agente de IA que trabaja a través de un plugin de Roblox Studio, así que crea los remotes y los scripts en tu Explorer en vez de darte código para pegar.
Deja que los jugadores hagan clic en las partes de la carpeta Paintable para pintarlas. Usa un RemoteEvent y deja las comprobaciones en el servidor: solo partes de esa carpeta, a menos de 30 studs, y no más de unas pocas pintadas por segundo.
- Normalmente revisa primero el place, con Search Game y Search Scripts, en busca de una carpeta Remotes o un manejador que ya exista, y usa tus carpetas cuando ya están ahí
- Crea el RemoteEvent en ReplicatedStorage con Create Instance, y escribe el Script del servidor y el LocalScript con Create Script
- Comprueba que cada script compila con Check Script dentro de Studio antes de terminar. Eso detecta errores de compilación, no errores de lógica: no verifica tipos, no hace lint ni ejecuta tu código
- Envía sus cambios por lotes, y cada lote es un punto de deshacer en el historial de Studio
Con el plugin 3.9 o posterior RoCode puede hacer una prueba corta y leer los errores, y con el plugin 3.9.11 o posterior puede controlar un personaje de prueba, pero no hace clic en partes en la vista 3D. Pulsa Play tú mismo e intenta romper las comprobaciones, por ejemplo pintando desde el otro lado del mapa. Si algo da error, Check Output puede leer las líneas de Server y Client de tu última prueba de juego. La mayoría de los sistemas de un juego hablan por remotes como estos, así que vuelven a aparecer cuando construyes un juego sistema por sistema con RoCode. Cómo se conecta RoCode a Studio.
Preguntas frecuentes
¿Qué significa asegurar la frontera entre cliente y servidor en Roblox?
Es el nombre de la página de la documentación de Roblox sobre la seguridad de los remotes, y la idea es simple: todo lo que un cliente envía por un RemoteEvent o una RemoteFunction puede venir de un exploiter, así que el servidor lo comprueba antes de actuar. Comprueba el tipo de cada argumento, mantén los números en un rango razonable, comprueba que el jugador tiene permiso para hacerlo en este momento y limita con qué frecuencia puede disparar cada jugador. La lista de validación de arriba muestra cada una de estas cosas en código.
¿Es seguro usar RemoteFunctions?
InvokeServer es tan seguro como tu callback del servidor: valida sus argumentos y limita su frecuencia como con cualquier RemoteEvent. InvokeClient es el sentido arriesgado, porque un cliente que da error, se va o nunca responde rompe o congela la llamada del servidor.
¿Los exploiters pueden ver y disparar mis remotes?
Sí. Todo lo que hay en ReplicatedStorage llega a todos los clientes, y un cliente modificado puede disparar cualquier remote con cualquier argumento. Cambiar el nombre de los remotes o esconderlos no los hace seguros; comprobar cada argumento en el servidor sí.
¿Un cliente puede enviar un RemoteEvent a otro cliente?
No directamente. Dispáralo al servidor, compruébalo ahí y luego usa FireClient o FireAllClients.
¿Con qué frecuencia puedo disparar un RemoteEvent?
Roblox documenta un límite de unas 500 peticiones por segundo por cliente para los mensajes de RemoteEvent y UnreliableRemoteEvent enviados al servidor, compartido por todos los remotes del mismo tipo. Quédate muy por debajo, y dale a cada manejador su propio límite por jugador.
¿FireAllClients llega a los jugadores que entran más tarde?
No. Llega a los jugadores conectados en ese momento. Para un estado que necesitan los que entran tarde, pon un atributo o un objeto de valor en el servidor.
¿Cuál es la diferencia entre un RemoteEvent y un BindableEvent?
Un RemoteEvent cruza entre servidor y cliente. Un BindableEvent conecta scripts del mismo lado, como dos scripts del servidor.
Fuentes y lecturas
- Roblox Creator Docs: Remote events and callbacks (en inglés). FireServer, FireClient, InvokeServer, riesgos de InvokeClient, limitaciones de los argumentos y garantías de entrega
- Roblox Creator Docs: Securing the client-server boundary (en inglés). Capas de validación, NaN, límites de frecuencia, reenvíos de cliente a cliente
- Roblox Creator Docs: Security and cheat mitigation tactics (en inglés). Qué puede hacer un cliente modificado, y la autoridad del servidor
- Roblox Creator Docs: Network ownership, movement validation, and physics (en inglés). Por qué un cliente controla su propio personaje, y los límites de las comprobaciones de distancia
- Roblox Engine API: RemoteEvent (en inglés). El límite de frecuencia y el error de invocation discarded
- Roblox Engine API: RemoteFunction (en inglés). OnServerInvoke, advertencias de InvokeClient y precauciones con el streaming
- Roblox Engine API: UnreliableRemoteEvent (en inglés). El límite de carga de 1000 bytes
- Roblox Creator Docs: Properties and attributes (en inglés). Orden de replicación entre los cambios de propiedades y los remote events
Cómo se comprobó el código: cada script de esta página pasa el verificador de tipos estricto de Luau con las definiciones de la API de Roblox (luau-lsp, 12 de noviembre de 2026). Una verificación de tipos detecta APIs mal escritas y tipos incorrectos, no la lógica del juego, así que pruébalo en Studio antes de publicar.