Урок · Основи на скриптирането

RemoteEvent в Roblox: от клиента към сървъра и обратно

LocalScript не може да промени това, което виждат другите играчи, а сървърният Script не може да стигне до екрана на един играч. Съобщенията между тях се предават от RemoteEvent. В това ръководство ще сглобим трите схеми, които ще ти трябват най-често, RemoteFunction, която връща отговор, и сървърните проверки, които не позволяват на модифициран клиент да злоупотребява с тях.

Обновено 20 ноември 2026 г.18 мин четенеАвтор:

Накратко

RemoteEvent е обект, който обикновено е в ReplicatedStorage и предава съобщения през границата между клиента и сървъра. LocalScript извиква FireServer и сървърът получава съобщението в OnServerEvent, където като първи аргумент е добавен изпратилият го Player. Сървърът извиква FireClient(player, ...) или FireAllClients(...), а LocalScript получават съобщението в OnClientEvent.

  • Използвай RemoteFunction (InvokeServer и OnServerInvoke) само когато на клиента му трябва отговор. Избягвай InvokeClient: клиент, при който е станала грешка, който е излязъл или никога не е върнал стойност, чупи извикването на сървъра.
  • Никога не се доверявай на това, което изпраща клиентът. На сървъра проверявай типа, обхвата и собствеността на всеки аргумент, разстоянието до играча и колко често извиква ремоута.
  • Функции, метатаблици и обекти, които другата страна не вижда, не оцеляват при изпращането. UnreliableRemoteEvent може да губи съобщения или да променя реда им и отхвърля всякакви данни над 1000 байта.
На тази страница
  1. Защо са нужни ремоути
  2. Настройка на ремоутите
  3. 1. От клиента към сървъра
  4. 2. От сървъра към клиента
  5. 3. От сървъра към всички
  6. RemoteFunction
  7. Чеклист за проверки
  8. Какво не може да се изпрати
  9. Връща nil?
  10. UnreliableRemoteEvent
  11. Ред и лимити
  12. Какво да избереш
  13. Common errors
  14. С RoCode
  15. Често задавани въпроси
  16. Източници и какво да прочетеш

Защо са нужни RemoteEvent

ИлюстрацияВсеки клик моли сървъра да боядиса парт, затова новият цвят се вижда на екраните и на двамата играчи.

Всяка игра в Roblox работи като един сървър плюс по един клиент за всеки играч. Сървърът тук е главният: нов обект или промяна на свойство стига до всички играчи само когато я направи сървърът. Промяна, направена в LocalScript, остава на едно устройство, с малки изключения като собствения персонаж на играча, чието движение се управлява от неговия клиент. Затова, когато клик или натискане на клавиш трябва да промени общия свят, клиентът трябва да помоли сървъра, а когато сървърът иска да реагира екранът на един играч, той трябва да съобщи на клиента. Ако разделението на Script и LocalScript е ново за теб, първо прочети Script vs LocalScript vs ModuleScript (на английски). Ако самото скриптиране е ново за теб, започни с това как да пишеш скриптове в Roblox Studio.

За пресичане на тази граница Roblox дава три обекта:

  • RemoteEvent: съобщение в една посока. Изпращачът веднага продължава работа.
  • RemoteFunction: заявка, която чака отговор. Кодът, който я е извикал, стои на пауза, докато другата страна не върне стойност.
  • UnreliableRemoteEvent: съобщение в една посока, което може да се загуби или да пристигне не по ред, но натоварва по-малко мрежата. Подходящо е за данни, които се променят постоянно.
Кое извикване пуска кое събитие
ПосокаИзпращачът извикваПолучателят се свързва сПолучателят получава
От клиента към сървъраremote:FireServer(...) в LocalScriptremote.OnServerEvent в ScriptPlayer, който е изпратил съобщението, после твоите аргументи
От сървъра към един клиентremote:FireClient(player, ...) в Scriptremote.OnClientEvent в LocalScriptСамо твоите аргументи
От сървъра към всички клиентиremote:FireAllClients(...) в Scriptremote.OnClientEvent в LocalScriptСамо твоите аргументи
Клиентът пита, сървърът отговаряremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player, после твоите аргументи. Извикващият получава това, което е върнала функцията

Клиентите не могат да си изпращат съобщения направо един на друг. За да предадеш нещо от един играч на останалите, изпрати го на сървъра, провери го там и нека сървърът го препрати чрез FireClient или FireAllClients. Според препоръките на Roblox за сигурност сървърът тук работи като пазач, а не като обикновен ретранслатор.

Къде да държиш ремоутите

Ремоутът трябва да е там, където го виждат и сървърът, и клиентите. Обичайното място е ReplicatedStorage; в документацията на Roblox е отбелязано, че в някои случаи стават и Workspace или Tool. ServerStorage и ServerScriptService са достъпни само за сървъра, затова LocalScript, който чака ремоут оттам, ще чака вечно.

  1. В Explorer задръж курсора над ReplicatedStorage, натисни бутона + и вмъкни Folder. Наречи папката Remotes.
  2. Задръж курсора над Remotes, натисни + и вмъкни RemoteEvent. Преименувай го така, че името да описва предназначението му, например PaintRequest.
  3. Повтори за всеки ремоут. В това ръководство се използват два RemoteEvent (PaintRequest и Notify) и една RemoteFunction (RedeemCode).
Explorer: всичко, което добавя това ръководство, раздел по раздел
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

Скриптовете в това ръководство намират ремоутите чрез WaitForChild. Той връща резултат веднага, ако ремоутът вече е на мястото си, и чака, ако още го няма, например когато сървърен скрипт създава ремоутите по време на игра. Създавай отделен ремоут за всеки вид заявка: тогава всеки сървърен обработчик проверява една форма на аргументите и е много по-лесно да го направиш правилно, отколкото с един ремоут за всички случаи.

Схема 1: от клиента към сървъра, с проверка на сървъра

Най-честата задача: играчът прави нещо на своя екран, а сървърът решава какво ще стане. Тук играчът натиска Q, за да избере един от четири цвята, и кликва или докосва парт, за да го боядиса. Новият цвят се вижда от всички, защото боядисва сървърът.

Клиентът изпраща две неща: кой парт и номера на цвета. Самия цвят никога не го изпраща, и в други игри по същия начин не трябва да изпраща цена, награда или размер на щетите. Модифициран клиент може да изпрати каквото си иска, затова истинските данни (тук това е палитрата) се пазят от сървъра, а аргументите той възприема като заявка, която трябва да се провери.

  1. В Workspace вмъкни Folder с име Paintable и сложи в нея няколко закотвени Part.
  2. Провери дали в ReplicatedStorage.Remotes има RemoteEvent с име PaintRequest.
  3. Вмъкни Script с име PaintServer в ServerScriptService и LocalScript с име PaintClient в StarterPlayer, StarterPlayerScripts, с кода по-долу.
Script в ServerScriptService с име 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")

-- Цветовете са на сървъра. Клиентът изпраща само номер, който избира един от тях.
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 -- стъда между персонажа и парта
local COOLDOWN_SECONDS = 0.25

local lastPaint: { [Player]: number } = {}

-- Първият параметър винаги е играчът, който е извикал ремоута. Подава го Roblox,
-- затова може да му се вярва. Всичко след него идва от клиента и на него не може да се вярва.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. Тип: истински парт, а не таблица, която се преструва на такъв
	if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
		return
	end

	-- 2. Обхват: цяло число от 1 до 4. NaN и безкрайността също се отсяват тук.
	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. Разрешена цел: само партове в папката Paintable, нищо друго в играта
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. Разстояние: персонажът на играча трябва да е близо до парта
	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. Лимит на честотата: едно боядисване на играч на всяка четвърт секунда
	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)

Всяка неуспешна проверка просто прави return. Няма нужда да обясняваш на измамнически клиент защо му е отказано.

LocalScript в StarterPlayerScripts с име 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 -- истинските цветове се пазят от сървъра
local selectedColour = 1

-- Лъчът може да улучва само партове в папката 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 -- клавишът или кликът са отишли в чата или на бутон
	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
			-- Молим, а не заповядваме: дали да боядиса, решава сървърът
			paintRequest:FireServer(result.Instance, selectedColour)
		end
	end
end)

gameProcessed е true, когато двигателят вече е обработил този вход, обикновено в интерфейса: клик върху бутон или клавиши, написани в текстово поле като реда на чата. Благодарение на тази проверка буквата Q, написана в съобщение, не сменя цвета.

Схема 2: от сървъра към един клиент

Сървърът изпраща съобщение на един играч чрез FireClient. Първият аргумент е Player, до когото е адресирано, а обработчикът на клиента получава само аргументите след него. Използвай това за всичко лично: известие, прозорец с награда, звук, който трябва да чуе само този играч. Ръководството за катсцени е по-голям разгледан пример: сървърът решава кога играчът ще види катсцената и изпраща кадрите ѝ на този един играч чрез FireClient, а камерата се движи от неговото устройство.

Тази двойка скриптове показва поздрав, когато играчът влезе. LocalScript сам сглобява малък банер, затова не е нужно да настройваш GUI.

Script в ServerScriptService с име WelcomeServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent

local function welcome(player: Player)
	-- Първият аргумент избира кой клиент ще получи съобщението. Никой друг няма да го види.
	notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end

Players.PlayerAdded:Connect(welcome)

-- В Studio можеш да влезеш, преди този скрипт да се свърже, затова поздравяваме всички, които вече са тук
for _, player in Players:GetPlayers() do
	welcome(player)
end
LocalScript в StarterPlayerScripts с име NotifyClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local player = Players.LocalPlayer

-- Малък банер в горната част на екрана, сглобен в кода
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

-- Тук няма параметър player: сървърът вече е избрал кой ще получи съобщението
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 -- скриваме, ако не е заменено от по-ново съобщение
			label.Visible = false
		end
	end)
end)

Сървърът изпраща съобщението при PlayerAdded, а това може да стане, преди този LocalScript да свърже своя обработчик. Това е нормално: Roblox поставя в опашка съобщенията на RemoteEvent, пристигнали преди появата на обработчика, и ги доставя по ред веднага щом обработчикът се свърже.

Клиентът няма нужда да се пази от сървъра: OnClientEvent може да бъде задействан само от сървърен код. Анотацията message: string е за проверката на типовете; тя не е проверка по време на изпълнение.

Схема 3: от сървъра към всички клиенти

FireAllClients изпраща едно и също съобщение на всеки свързан играч. Той няма аргумент Player и всеки клиент получава съобщението в същия OnClientEvent като преди, затова скриптът NotifyClient от схема 2 вече го показва.

Този Script обявява на всички, когато играч за първи път докосне финалната линия. Добави в Workspace закотвен Part с име FinishLine, после добави Script в ServerScriptService.

Script в ServerScriptService с име 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 -- не е играч или вече е обявен
	end
	finished[player] = true

	-- Всеки свързан клиент пуска своя обработчик OnClientEvent с този текст
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

Players.PlayerRemoving:Connect(function(player: Player)
	finished[player] = nil
end)

Експлойтър може да задейства Touched за своя персонаж от всяко разстояние, но за обявление, което се показва веднъж на играч, това е безвредно. Ако по-късно даваш награда за финала, добави сървърни проверки преди да я дадеш, например минимално време от началото на рунда.

FireAllClients стига само до играчите, свързани в този момент. Който влезе секунда по-късно, вече няма да види съобщението. Това е подходящо за еднократни моменти като обявление, ефект от експлозия или звук, но не е подходящо за състояние като таймер на рунда или текущата фаза на играта. За състояние задай на сървъра атрибут, например ReplicatedStorage:SetAttribute("TimeLeft", 30), и го чети на клиента чрез GetAttribute и GetAttributeChangedSignal("TimeLeft"). Атрибутите се репликират на всеки клиент, включително на играчите, влезли по-късно.

RemoteFunction: когато на клиента му трябва отговор

RemoteEvent работи на принципа „изпрати и забрави“. RemoteFunction кара извикващия да чака: InvokeServer поставя на пауза кода, който го е извикал, докато сървърната функция OnServerInvoke не върне стойност, и после дава това, което тя е върнала. Използвай я, когато клиентът не може да продължи без отговор, например „верен ли беше този код?“. Когато отговор не е нужен, Roblox препоръчва RemoteEvent, защото той не чака.

Пример: поле, в което играчите въвеждат промокод. Сървърът пази кодовете, проверява текста и връща две стойности: дали е сработило и съобщението, което трябва да се покаже.

  1. В ReplicatedStorage.Remotes вмъкни RemoteFunction с име RedeemCode.
  2. В StarterGui вмъкни ScreenGui с име CodeGui, а в него TextBox с име CodeBox. Размера и мястото избери по свой вкус.
  3. Добави Script по-долу в ServerScriptService, а LocalScript в CodeBox.
Script в ServerScriptService с име RedeemServer
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction

-- Кодовете живеят на сървъра, където никой играч не може да ги прочете
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 } = {}

-- Присвояваме с =. OnServerInvoke е колбек, а не събитие, с което се прави 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)

Той добавя към показателя Coins от ръководството за класация. Използваните кодове се помнят само докато играчът не излезе, затова в този вид играчът може да влезе отново и да въведе същия код пак. Ако монетите се запазват, това са безплатни монети при всяко повторно влизане: преди да използваш това в жива игра, пази използваните кодове на всеки играч заедно с неговите запазени данни в хранилище за данни.

LocalScript в TextBox CodeBox с име 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 поставя тази функция на пауза, докато колбекът на сървъра не върне стойност.
	-- pcall не дава на LocalScript да спре, ако извикването не успее.
	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)

RemoteFunction има точно един сървърен колбек. Ако два скрипта задават OnServerInvoke на една и съща RemoteFunction, работи само последният.

Защо InvokeClient е опасен

RemoteFunction работи и в обратната посока, с InvokeClient на сървъра и OnClientInvoke на клиента. Документацията на Roblox изброява три сериозни риска:

  • Ако колбекът на клиента даде грешка, сървърът също дава грешка.
  • Ако играчът излезе по време на извикването, InvokeClient дава грешка.
  • Ако клиентът така и не върне стойност, сървърният скрипт ще чака вечно.

Модифициран клиент управлява своя колбек, затова измамник може нарочно да предизвика третия случай и да държи тази сървърна нишка колкото си иска. За да обновиш екрана на играч, използвай FireClient. Ако на сървъра наистина му трябва информация от клиента, изпрати RemoteEvent, нека клиентът отговори чрез друг RemoteEvent, а липсата на отговор приемай на сървъра за нормален случай.

Проверявай всеки аргумент на сървъра

Експлойтър може да извика всеки RemoteEvent или всяка RemoteFunction колкото пъти иска и с каквито иска аргументи. Единственото, което не може да подправи, е първият параметър: Roblox сам подава Player, който е изпратил съобщението. Всичко след него трябва да се провери, преди сървърът да започне да действа. Да скриваш ремоута или да проверяваш в LocalScript е безполезно, защото измамникът управлява своя клиент.

Чеклист за сървъра
ПроверкаВъпросът, който задава сървърътПример
ТипТова ли е типът, който очаквам? Instance, а не таблица, сглобена така, че да прилича на него?typeof(part) == "Instance" and part:IsA("BasePart")
ОбхватЧислото крайно ли е и в допустимите граници ли е? Текстът с разумна дължина ли е?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
СобственостПритежава ли този играч предмета, стигат ли му парите, има ли право да действа с този обект?Предметът е в инвентара му; партът е в Paintable
РазстояниеДостатъчно близо ли е персонажът на играча в сървърното копие на света? Остави малък резерв за лаг.Не по-далеч от 30 стъда от парта
ЧестотаНе изпраща ли този играч твърде често?Кулдаун на играч или лимит с натрупване на извиквания

NaN заслужава отделно предупреждение. Това е число, затова type(x) == "number" минава, но всяко сравнение с него дава false и проверка като x < 0 or x > 100 го пропуска. math.isfinite(x) отхвърля NaN и двете безкрайности.

Помни границата на проверката за разстояние. Всеки клиент управлява физиката на своя персонаж, затова експлойтър може преди извикването да премести персонажа до целта. Проверката пак спира най-простата злоупотреба, когато от едно място се действа по цялата карта. Дръж целевите партове закотвени: в документацията на Roblox за сигурност е отбелязано, че експлойтър може да получи мрежова собственост над незакотвени партове близо до себе си и да ги придърпа, а това заобикаля проверката за разстояние.

Ето същите проверки като ModuleScript, който можеш да използваш във всеки обработчик на ремоут.

ModuleScript в ServerScriptService с име RemoteGuard
local Players = game:GetService("Players")

local RemoteGuard = {}

-- Истинско число между min и max. Отхвърля NaN и безкрайност, които минават
-- обикновената проверка 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

-- Цяло число между min и max, за количества, индекси и броячи
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

-- Текст с ограничена дължина. utf8.len връща nil за невалиден UTF-8, който
-- хранилищата за данни отхвърлят.
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

-- Instance от очаквания клас в контейнер, който си разрешил.
-- Таблица, сглобена така, че да прилича на Instance, не минава проверката 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, когато персонажът на играча е не по-далеч от maxDistance стъда от 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

-- Лимит на честотата за всеки играч. Всеки играч може да направи `burst` извиквания наведнъж и
-- получава обратно `perSecond` извиквания всяка секунда. Връща функция, която се извиква
-- преди работата: тя отговаря true (може) или false (твърде често).
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

Дръж го в ServerScriptService. Кодът оттам никога не стига до клиентите, затова никой няма да прочете твоите проверки.

А ето обработчика от схема 1, пренаписан с негова помощ. Замени съдържанието на PaintServer:

Script в ServerScriptService с име PaintServer
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")

-- ":: any" има значение само за строгата проверка на типовете в Luau; по време на изпълнение не променя нищо
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) -- пакет от 4, после 4 в секунда

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)

Лимитерът изтрива записа на играча, когато той излезе, затова таблицата му не расте през целия живот на сървъра.

При оръжията тези проверки са най-важни: никога не позволявай на клиента да съобщава кого е улучил. Ремоутът от ръководството за меч изобщо не носи аргументи и сървърът сам намира целите. Ръководството за оръжие изпраща само точката на прицелване, която сървърът проверява за тип, NaN и разстояние, преди да пусне собствен лъч.

Менютата следват същото правило: изпращай избора, а не резултата. В ръководството за диалози с NPC клиентът изпраща само номера на натиснатия бутон, а сървърът сам гледа какво дава този отговор. Менюто от ръководството за телепорти изпраща името на точката, а не позицията, и сървърът намира точката в своята папка и проверява колко Wins са нужни за нея.

Какво може и какво не може да се изпраща

Можеш да предаваш числа, низове, булеви стойности, типове на Roblox като Vector3, CFrame, Color3 и елементи на Enum, Instance, които виждат и двете страни, и таблици от всичко това. Някои стойности по пътя се променят или изчезват:

Аргументи, които пристигат различни от изпратените
ИзпращашКакво става
ФункцияДругата страна получава nil
Таблица с метатаблицаМетатаблицата се губи заедно с всичко, което таблицата е имала само чрез нея
Таблица със смесени числови и низови ключовеRoblox съветва да не се прави така: изпращай чист масив или чист речник
Таблица със стойности nil вътреИзбягвай: Roblox не съветва nil на какъвто и да е индекс
Таблица с ключове от тип Instance, userdata или functionТакива ключове се превръщат в низове
Instance, който получателят не вижда, например от ServerStorage или създаден в LocalScriptДругата страна получава nil
Всяка таблицаПолучателят получава копие, а не същата таблица

Добър навик: изпращай идентификатори, а не обекти или стойности. Име на предмет, номер на вариант, парт, който сървърът може да намери и провери. Нататък сървърът работи със своите данни.

Защо RemoteFunction връща nil

Ако InvokeServer ти връща nil, мини през тези точки по ред:

  1. Път без върната стойност. Всеки изход от OnServerInvoke трябва да връща нещо. Празен return в ранна проверка изпраща обратно nil.
  2. return във вложена функция. return в pcall(function() ... end), обработчик на :Connect или task.spawn излиза само от тази вътрешна функция. Запази резултата, например local ok, data = pcall(...), и после върни data от самия колбек.
  3. Стойност, която не може да мине границата. Функция или Instance, който клиентът не вижда (например всичко в ServerStorage), пристига като nil. При включен instance streaming парт, който сървърът току-що е създал, може още да не е стигнал до клиента в момента на връщането от функцията.
  4. Колбекът е зададен от друг скрипт. Работи само последното присвояване на OnServerInvoke. Потърси името на ремоута в своите скриптове.

Ако извикването изобщо не се връща, значи никой скрипт още не е задал OnServerInvoke (Roblox държи извикванията в опашка, докато не бъде зададен) или колбекът е заседнал, например на WaitForChild за нещо, което никога няма да се появи.

UnreliableRemoteEvent: за постоянни еднократни обновления

UnreliableRemoteEvent има същите методи и събития като RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent и OnClientEvent. Разликата е, че Roblox не гарантира нито доставката, нито реда. Съобщението може да бъде отхвърлено без повторно изпращане, когато:

  • се загуби по пътя или чака твърде дълго в претоварена мрежа
  • данните му са над 1000 байта
  • клиентът изпраща по-често от лимита (излишното се отхвърля, а не се отлага)
  • в момента на пристигането не е свързан нито един обработчик (изхвърля се, а не се поставя в опашка)

Съобщенията могат да пристигат и не по ред, а редът им няма никаква връзка с твоите RemoteEvent или RemoteFunction. Използвай го, когато значение има само най-новата стойност, а следващото обновление ще дойде след част от секундата: накъде се цели играчът, позицията на козметичен ефект, стойност, която се променя всеки кадър. Ако редът е важен, слагай във всяко съобщение пореден номер или времеви печат и игнорирай всичко, което е по-старо от последното обработено.

Никога не го използвай за нещо, което трябва да се случи точно веднъж, например покупка, щети, награда или старт на рунд. И проверявай аргументите му на сървъра точно както при RemoteEvent.

Ред на доставка и лимити на честотата

Гаранциите за доставка на Roblox се отнасят за една връзка в една посока: от сървъра към един клиент или от един клиент към сървъра.

  • RemoteEvent са надеждни и подредени. Загубените съобщения се изпращат отново, докато получателят остава свързан, и съобщенията пристигат в реда, в който си ги изпратил, дори през различни RemoteEvent. Ако сървърът изпрати на играч A, после B, после A, този играч получава A, B, A.
  • Редът се отнася до момента на пускане на обработчиците. Ако обработчикът отстъпи управлението, например чрез task.wait или WaitForChild, следващото съобщение може да започне да се обработва, преди да е приключило първото.
  • RemoteFunction и RemoteEvent не са подредени едно спрямо друго. Ако кодът ти зависи от строг ред, изпращай свързаните съобщения през един тип ремоут или добави свой пореден номер.
  • Промените на свойства и атрибути не са подредени спрямо ремоутите. Ако сървърът промени свойство и после извика ремоут, клиентът може да види първо което и да е от двете. Слушай самата промяна, например чрез GetPropertyChangedSignal, вместо да разчиташ, че вече е пристигнала.
  • Обработчикът още го няма. Съобщенията на RemoteEvent стоят в опашка, докато не се свърже обработчик. Опашката има граници: когато е пълна, следващите съобщения се отхвърлят, а в Output се появява грешката Remote event invocation discarded.
  • Играч, който излиза, губи всички съобщения, които още не са стигнали до него.

Лимит на честотата. Съобщенията на RemoteEvent и UnreliableRemoteEvent от клиента към сървъра са ограничени до около 500 заявки в секунда на клиент, според документацията към 30 септември 2026. Лимитът е общ за всички ремоути от един тип, затова разделянето на един натоварен ремоут на десет не го вдига. Над лимита съобщенията на RemoteEvent се обработват по-късно и запазват реда си, а съобщенията на UnreliableRemoteEvent се отхвърлят. Лимитът на двигателя по никакъв начин не пречи на един играч да извиква твоя ремоут 50 пъти в секунда, затова всеки обработчик, който променя нещо, пак има нужда от свой лимит на играч.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent или атрибут?

Как да избереш начина на общуване между клиента и сървъра
ИзползвайЗа каквоПримерЗа какво да внимаваш
RemoteEventСъобщения в една посока, които трябва да стигнат, и то по редКлиентът: „боядисай този парт“. Сървърът: „покажи това известие“Проверявай всеки аргумент на сървъра
RemoteFunction с InvokeServerНа клиента му трябва отговор, преди да може да продължиВъвеждане на промокод, потвърждаване на покупкаИзвикващият чака; всеки път трябва да връща стойност
RemoteFunction с InvokeClientПочти никогаИзползвай вместо това FireClientКлиент с грешка, който е излязъл или не е отговорил, чупи или задържа извикването на сървъра
UnreliableRemoteEventЧести обновления, при които значение има само последнотоПосока на прицела, козметични ефектиСъобщенията се губят или сменят реда си; лимит на данните 1000 байта
Атрибут или value обект, зададен от сървъраОбщо състояние, което трябва да се вижда винаги, включително от играчите, влезли по-късноТаймер на рунда, фаза на играта, дали вратата е отворенаДо всички стигат само промените на сървъра; клиентите слушат чрез GetAttributeChangedSignal или Changed
BindableEventОбщуване между скриптове на една и съща странаЕдин сървърен скрипт съобщава на друг, че рундът е свършилНе минава между сървъра и клиента

Пълен пример за това как RemoteFunction и проверките работят заедно там, където играчите плащат, ще намериш в ръководството как да направиш GUI за магазин. Що се отнася до реда за атрибутите, сървърният скрипт от ръководството за врати задава атрибута Open на всяка врата при всяко нейно движение, така че всеки LocalScript може да реагира на него.

Чести грешки и решения

Повечето проблеми с ремоутите се виждат в прозореца Output (отвори го от менюто Window или от раздела Script). Първо погледни там, после намери своя симптом по-долу. Ръководството за грешки в скриптовете разглежда по-подробно общите съобщения за грешки.

Infinite yield possible при WaitForChild за ремоут

Скриптът чака ремоут, който никога няма да се появи. Провери дали името и главните букви съвпадат точно и дали ремоутът е в ReplicatedStorage, а не в ServerStorage или ServerScriptService, които клиентите не виждат.

Сървърът получава грешни стойности, изместени с една

LocalScript е подал самия играч, като в remote:FireServer(player, 5). Roblox и без това добавя изпращача като първи параметър, затова сървърът вижда (player, player, 5). Извиквай remote:FireServer(5).

Нищо не става, когато извикам ремоута

Провери дали всяко извикване идва от правилната страна: FireServer и InvokeServer работят само от клиентски код, а FireClient, FireAllClients и InvokeClient само от сървърен Script. LocalScript никога не се стартира в ServerScriptService, ServerStorage или направо в Workspace; слагай го в StarterPlayerScripts, StarterGui, StarterCharacterScripts или StarterPack. После потърси в Output грешка в обработчика.

Remote event invocation discarded

Пристигнали са съобщения за RemoteEvent, който не е имал свързан обработчик, и опашката се е напълнила. Обикновено скриптът с обработчика пада с грешка преди реда с :Connect, изключен е или е заседнал в чакане на нещо, което никога няма да се зареди. Свързвай обработчиците по-близо до началото на скрипта.

При мен работи, но другите играчи не виждат промяната

Промяната е направена на клиента, в LocalScript или в обработчик на OnClientEvent. Прави я в сървърния обработчик на OnServerEvent.

InvokeServer никога не се връща

Или никой скрипт не е задал OnServerInvoke (Roblox държи извикванията в опашка, докато не бъде зададен), или колбекът е заседнал на нещо, което отстъпва управлението, например на WaitForChild или заявка към хранилището за данни. Добави print в началото и в края на колбека, за да видиш къде спира.

Направи го с RoCode

Това може да го настрои и RoCode, направо в отворения ти плейс. RoCode е ИИ агент, който работи чрез плъгин за Roblox Studio, затова създава ремоутите и скриптовете в твоя Explorer, вместо да ти дава код за поставяне.

Ти пишеш

Нека играчите боядисват партовете в папката Paintable с клик. Използвай RemoteEvent и остави проверките на сървъра: само партове от тази папка, не по-далеч от 30 стъда и не повече от няколко боядисвания в секунда.

RoCode прави
  • Обикновено първо разглежда плейса чрез Search Game и Search Scripts за готова папка Remotes или обработчик и използва твоите папки, ако ги има
  • Създава RemoteEvent в ReplicatedStorage чрез Create Instance и пише сървърен Script и LocalScript чрез Create Script
  • Преди да приключи, проверява компилирането на всеки скрипт чрез Check Script в Studio. Това хваща грешки при компилиране, а не грешки в логиката: не проверява типовете, не пуска линтер и не изпълнява твоя код
  • Изпраща промените на групи и всяка група е точка за отмяна в историята на Studio

С плъгин 3.9 или по-нов RoCode може да пусне кратък плейтест и да прочете грешките, а с плъгин 3.9.11 или по-нов може да управлява тестов персонаж, но не кликва върху партове в 3D прозореца. Натисни Play сам и опитай да счупиш проверките, например като боядисаш парт от другия край на картата. Ако се появи грешка, Check Output може да прочете редовете Server и Client от последния ти плейтест. Повечето системи в игрите общуват чрез такива ремоути, затова ще ги срещнеш отново, когато сглобяваш игра система по система с RoCode. Как RoCode се свързва със Studio.

Често задавани въпроси

Какво означава securing the client-server boundary в Roblox?

Така се казва страницата от документацията на Roblox за сигурността на ремоутите, а идеята е проста: всичко, което клиентът изпраща чрез RemoteEvent или RemoteFunction, може да идва от експлойтър, затова сървърът го проверява, преди да действа. Проверявай типа на всеки аргумент, дръж числата в разумни граници, проверявай дали на играча в момента му е позволено да прави това, и ограничавай колко често всеки играч може да извиква ремоута. Чеклистът за проверки по-горе показва всяка от тях в код.

Безопасно ли е да използвам RemoteFunction?

InvokeServer е толкова безопасен, колкото е безопасен сървърният ти колбек: проверявай аргументите му и ограничавай честотата, както при всеки RemoteEvent. Рисковата посока е InvokeClient, защото клиент с грешка, който е излязъл или никога не е върнал стойност, чупи или задържа извикването на сървъра.

Могат ли експлойтърите да виждат и извикват моите ремоути?

Да. Всичко, което е в ReplicatedStorage, стига до всеки клиент, а модифициран клиент може да извика всеки ремоут с всякакви аргументи. Преименуването или скриването на ремоутите не ги прави безопасни; безопасни ги прави проверката на всеки аргумент на сървъра.

Може ли един клиент да изпрати RemoteEvent на друг клиент?

Направо не. Изпрати го на сървъра, провери го там, после използвай FireClient или FireAllClients.

Колко често мога да извиквам RemoteEvent?

В документацията на Roblox е посочен лимит от около 500 заявки в секунда на клиент за съобщенията на RemoteEvent и UnreliableRemoteEvent, изпратени към сървъра, общ за всички ремоути от един тип. Стой много под него и дай на всеки обработчик свой лимит на играч.

Стига ли FireAllClients до играчите, които влизат по-късно?

Не. Стига до играчите, свързани в този момент. За състояние, което трябва на закъснелите, задай на сървъра атрибут или value обект.

Каква е разликата между RemoteEvent и BindableEvent?

RemoteEvent минава между сървъра и клиента. BindableEvent свързва скриптове на една и съща страна, например два сървърни скрипта.

Източници и какво да прочетеш

Как е проверен кодът: всеки скрипт на тази страница минава строга проверка на типовете в Luau с дефинициите на Roblox API (luau-lsp, 20 ноември 2026 г.). Проверката на типовете хваща грешки в имената на API и грешни типове, но не и грешки в логиката на играта, затова тествай всичко в Studio, преди да публикуваш.

Пробвай RoCode в своята игра.

Безплатни кредити всеки ден, без карта. Инсталирай плъгина, опиши функцията и виж какво се е появило в Studio.