Tutorial · Fundamentos de scripting

RemoteEvents en Roblox: del cliente al servidor y de vuelta

Un LocalScript no puede cambiar lo que ven los demás jugadores, y un Script del servidor no puede tocar la pantalla de un jugador. Los RemoteEvents llevan mensajes entre los dos. Esta guía construye los tres patrones que más vas a usar, una RemoteFunction que devuelve una respuesta y las comprobaciones del servidor que impiden que un cliente modificado abuse de ellos.

Actualizado el 12 de noviembre de 202620 min de lecturaEscrito por

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 (InvokeServer y OnServerInvoke) solo cuando el cliente necesita una respuesta. Evita InvokeClient: 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
  1. Por qué existen
  2. Preparar los remotes
  3. 1. Cliente a servidor
  4. 2. Servidor a un cliente
  5. 3. Servidor a todos
  6. RemoteFunctions
  7. Lista de validación
  8. Qué no se puede enviar
  9. ¿Devuelve nil?
  10. UnreliableRemoteEvent
  11. Orden y límites
  12. Cuál usar
  13. Errores comunes
  14. Con RoCode
  15. Preguntas frecuentes
  16. Fuentes y lecturas

Por qué existen los RemoteEvents

IlustraciónCada clic le pide al servidor que pinte la parte, así que las pantallas de los dos jugadores muestran el color nuevo.

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.
Qué llamada dispara qué evento
DirecciónEl emisor llama aEl receptor se conecta aEl receptor recibe
Del cliente al servidorremote:FireServer(...) en un LocalScriptremote.OnServerEvent en un ScriptEl Player que disparó, y luego tus argumentos
Del servidor a un clienteremote:FireClient(player, ...) en un Scriptremote.OnClientEvent en un LocalScriptSolo tus argumentos
Del servidor a todos los clientesremote:FireAllClients(...) en un Scriptremote.OnClientEvent en un LocalScriptSolo tus argumentos
El cliente pregunta, el servidor responderemoteFunction: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.

  1. En el Explorer, pasa el ratón sobre ReplicatedStorage, haz clic en el botón + e inserta una Folder. Llámala Remotes.
  2. Pasa el ratón sobre Remotes, haz clic en + e inserta un RemoteEvent. Cámbiale el nombre para que describa su propósito, por ejemplo PaintRequest.
  3. Repite para cada remote. Esta guía usa dos RemoteEvents (PaintRequest y Notify) y una RemoteFunction (RedeemCode).
Explorer: todo lo que añade esta guía, sección por sección
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.

  1. En Workspace, inserta una Folder llamada Paintable y pon dentro algunas Parts ancladas.
  2. Comprueba que ReplicatedStorage.Remotes tiene un RemoteEvent llamado PaintRequest.
  3. Inserta un Script en ServerScriptService llamado PaintServer, y un LocalScript en StarterPlayer, StarterPlayerScripts llamado PaintClient, con el código de abajo.
Script en ServerScriptService llamado 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")

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

LocalScript en StarterPlayerScripts llamado 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 -- 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.

Script en ServerScriptService llamado WelcomeServer
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
LocalScript en StarterPlayerScripts llamado NotifyClient
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.

Script en ServerScriptService llamado 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 -- 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.

  1. En ReplicatedStorage.Remotes, inserta una RemoteFunction llamada RedeemCode.
  2. En StarterGui, inserta un ScreenGui llamado CodeGui, y dentro un TextBox llamado CodeBox. Dale el tamaño y la posición que quieras.
  3. Añade el Script de abajo a ServerScriptService, y el LocalScript dentro de CodeBox.
Script en ServerScriptService llamado RedeemServer
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.

LocalScript en el TextBox CodeBox llamado 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 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, InvokeClient lanza 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.

La lista de comprobaciones del servidor
ComprobaciónLa pregunta que se hace el servidorEjemplo
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.

ModuleScript en ServerScriptService llamado RemoteGuard
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:

Script en ServerScriptService llamado 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:

Argumentos que no llegan como se enviaron
EnvíasQué pasa
Una funciónEl otro lado recibe nil
Una tabla con metatablaLa 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 textoRoblox dice que no lo hagas: envía un array puro o un diccionario puro
Una tabla con valores nil dentroEvítalo: Roblox desaconseja nil en cualquier índice
Una tabla con claves que son Instance, userdata o funciónEsas claves se convierten en strings
Una Instance que el receptor no puede ver, como una en ServerStorage o una creada por un LocalScriptEl otro lado recibe nil
Cualquier tablaEl 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:

  1. Un camino sin valor de retorno. Toda salida de OnServerInvoke debe devolver algo. Un return a secas en una comprobación temprana devuelve nil.
  2. Un return dentro de una función anidada. Un return dentro de pcall(function() ... end), de un manejador de :Connect o de task.spawn solo sale de esa función interna. Captura el resultado, por ejemplo local ok, data = pcall(...), y luego devuelve data desde el propio callback.
  3. 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.
  4. 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.wait o WaitForChild, 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?

Cómo elegir la forma en que hablan el cliente y el servidor
UsaParaEjemploTen cuidado con
RemoteEventMensajes de un solo sentido que deben llegar, en ordenCliente: "pinta esta parte". Servidor: "muestra este aviso"Valida cada argumento en el servidor
RemoteFunction con InvokeServerEl cliente necesita una respuesta antes de poder seguirCanjear un código, confirmar una compraEl que llama espera; todos los caminos deben devolver un valor
RemoteFunction con InvokeClientCasi nuncaUsa FireClient en su lugarUn cliente que da error, se va o nunca responde rompe o congela la llamada del servidor
UnreliableRemoteEventActualizaciones frecuentes donde solo importa la últimaDirección de la mira, efectos cosméticosMensajes perdidos o desordenados; límite de carga de 1000 bytes
Atributo u objeto de valor puesto por el servidorEstado compartido que siempre debe estar visible, también para los jugadores que entran más tardeTemporizador de ronda, fase del juego, si una puerta está abiertaSolo los cambios del servidor llegan a todos; los clientes escuchan con GetAttributeChangedSignal o Changed
BindableEventScripts del mismo lado que hablan entre síUn script del servidor que avisa a otro de que terminó una rondaNo 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.

Tú escribes

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.

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

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.

Prueba RoCode en tu propio juego.

Créditos gratis cada día, sin tarjeta. Instala el plugin, describe la función y revisa lo que aparece en Studio.