Röviden
A RemoteEvent egy objektum, amely általában a ReplicatedStorage-ban van, és üzeneteket visz át a kliens és a szerver közötti határon. Egy LocalScript meghívja a FireServer függvényt, a szerver pedig az OnServerEvent eseményben kapja meg az üzenetet, ahol első argumentumként a küldő Player is hozzá van adva. A szerver meghívja a FireClient(player, ...) vagy a FireAllClients(...) függvényt, és a LocalScriptek az OnClientEvent eseményben kapják meg az üzenetet.
- A RemoteFunctiont (
InvokeServerésOnServerInvoke) csak akkor használd, ha a kliensnek válasz kell. Kerüld azInvokeClient-et: egy kliens, amelynél hiba történt, amely kilépett, vagy amely soha nem adott vissza értéket, elrontja a hívást a szerveren. - Soha ne bízz abban, amit a kliens küld. A szerveren ellenőrizd minden argumentum típusát, tartományát és tulajdonjogát, a játékos távolságát, és hogy milyen gyakran hívja a remote-ot.
- A függvények, a metatáblák és azok az objektumok, amelyeket a másik oldal nem lát, nem élik túl az átküldést. Az UnreliableRemoteEvent elveszítheti az üzeneteket vagy felcserélheti a sorrendjüket, és minden 1000 bájtnál nagyobb adatot eldob.
Ezen az oldalon
- Mire valók a remote-ok
- A remote-ok beállítása
- 1. A klienstől a szerverhez
- 2. A szervertől a klienshez
- 3. A szervertől mindenkihez
- RemoteFunction
- Ellenőrzőlista
- Amit nem lehet elküldeni
- Nil-t ad vissza?
- UnreliableRemoteEvent
- Sorrend és korlátok
- Mit válassz
- Common errors
- RoCode-dal
- Gyakori kérdések
- Források és további olvasnivaló
Mire valók a RemoteEventek
Minden Roblox játék egy szerverként és játékosonként egy kliensként működik. Itt a szerver a főnök: egy új objektum vagy egy tulajdonság módosítása csak akkor jut el minden játékoshoz, ha a szerver végzi. A LocalScriptben végzett változtatás egyetlen eszközön marad, néhány kivétellel, például a játékos saját karakterénél, amelynek a mozgását a kliense irányítja. Ezért amikor egy kattintásnak vagy gombnyomásnak a közös világot kell megváltoztatnia, a kliensnek meg kell kérnie a szervert, és amikor a szerver azt akarja, hogy egyetlen játékos képernyője reagáljon, szólnia kell erről a kliensnek. Ha a Script és LocalScript szétválasztása új neked, előbb olvasd el a Script vs LocalScript vs ModuleScript útmutatót (angolul). Ha maga a scriptelés új, kezdd azzal, hogyan írj scripteket a Roblox Studióban.
A határ átlépésére a Roblox három objektumot ad:
- RemoteEvent: egyirányú üzenet. A küldő azonnal folytatja a munkát.
- RemoteFunction: kérés, amely választ vár. A hívó kód szünetel, amíg a másik oldal vissza nem ad egy értéket.
- UnreliableRemoteEvent: egyirányú üzenet, amely elveszhet vagy rossz sorrendben érkezhet, cserébe kevésbé terheli a hálózatot. Folyamatosan változó adatokhoz való.
| Irány | A küldő meghívja | A fogadó erre csatlakozik | A fogadó megkapja |
|---|---|---|---|
| A klienstől a szerverhez | remote:FireServer(...) egy LocalScriptben | remote.OnServerEvent egy Scriptben | Az üzenetet küldő Player, majd a te argumentumaid |
| A szervertől egy klienshez | remote:FireClient(player, ...) egy Scriptben | remote.OnClientEvent egy LocalScriptben | Csak a te argumentumaid |
| A szervertől minden klienshez | remote:FireAllClients(...) egy Scriptben | remote.OnClientEvent egy LocalScriptben | Csak a te argumentumaid |
| A kliens kérdez, a szerver válaszol | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | A Player, majd a te argumentumaid. A hívó azt kapja meg, amit a függvény visszaadott |
A kliensek nem tudnak közvetlenül üzenni egymásnak. Ha valamit egy játékostól a többieknek akarsz továbbítani, küldd el a szervernek, ott ellenőrizd, és a szerver küldje tovább a FireClient vagy a FireAllClients segítségével. A Roblox biztonsági ajánlásai szerint a szerver itt kapuőrként működik, nem egyszerű továbbítóként.
Hol tárold a remote-okat
A remote-nak olyan helyen kell lennie, ahol a szerver és a kliensek is látják. A szokásos hely a ReplicatedStorage; a Roblox dokumentációja megjegyzi, hogy bizonyos esetekben a Workspace vagy egy Tool is megfelel. A ServerStorage és a ServerScriptService csak a szerver számára érhető el, ezért egy LocalScript, amely onnan vár egy remote-ot, örökké várni fog.
- Az Explorerben vidd a kurzort a ReplicatedStorage fölé, kattints a + gombra, és illessz be egy Foldert. Nevezd el a mappát
Remotesnéven. - Vidd a kurzort a
Remotesfölé, kattints a + gombra, és illessz be egy RemoteEventet. Nevezd át úgy, hogy a neve leírja a célját, példáulPaintRequest. - Ismételd meg minden remote-nál. Ez az útmutató két RemoteEventet (
PaintRequestésNotify) és egy RemoteFunctiont (RedeemCode) használ.
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
Az útmutató scriptjei a WaitForChild segítségével találják meg a remote-okat. Azonnal visszatér, ha a remote már a helyén van, és vár, ha még nincs ott, például amikor egy szerverscript játék közben hozza létre a remote-okat. Minden kéréstípushoz külön remote-ot hozz létre: így minden szerveroldali kezelő egyetlen argumentumformát ellenőriz, és ezt helyesen megcsinálni sokkal egyszerűbb, mint egy mindenre használt remote-tal.
1. minta: a klienstől a szerverhez, szerveroldali ellenőrzéssel
A leggyakoribb feladat: a játékos csinál valamit a saját képernyőjén, a szerver pedig eldönti, mi történjen. Itt a játékos a Q megnyomásával választ a négy szín közül, és egy partra kattintva vagy koppintva kifesti. Az új színt mindenki látja, mert a szerver fest.
A kliens két dolgot küld: melyik partot, és a szín számát. Magát a színt soha nem küldi el, és más játékokban ugyanígy nem szabad elküldenie az árat, a jutalmat vagy a sebzés mértékét. Egy módosított kliens bármit elküldhet, ezért a valódi adatokat (itt a palettát) a szerver tárolja, az argumentumokat pedig ellenőrizendő kérésként kezeli.
- A Workspace-be illessz be egy
Paintablenevű Foldert, és tegyél bele néhány rögzített Partot. - Ellenőrizd, hogy a
ReplicatedStorage.Remotesmappában van-e egyPaintRequestnevű RemoteEvent. - Illessz be egy
PaintServernevű Scriptet a ServerScriptService-be és egyPaintClientnevű LocalScriptet a StarterPlayer, StarterPlayerScripts helyre, az alábbi kóddal.
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")
-- A színek a szerveréi. A kliens csak egy számot küld, amely kiválaszt egyet közülük.
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 -- stud a karakter és a part között
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- Az első paraméter mindig a remote-ot hívó játékos. Ezt a Roblox adja hozzá,
-- ezért megbízhatsz benne. Minden, ami utána jön, a klienstől érkezett, és abban nem bízhatsz.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. Típus: valódi part, nem egy tábla, amely annak tetteti magát
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. Tartomány: egész szám 1 és 4 között. A NaN és a végtelen is itt esik ki.
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. Engedélyezett cél: csak a Paintable mappa partjai, semmi más a játékban
if not part:IsDescendantOf(paintable) then
return
end
-- 4. Távolság: a játékos karakterének a part közelében kell lennie
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. Gyakoriságkorlát: játékosonként egy festés negyed másodpercenként
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)
Minden sikertelen ellenőrzés egyszerűen return-t hajt végre. Semmi értelme elmagyarázni a csaló kliensnek, miért utasították el.
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 -- a valódi színeket a szerver tárolja
local selectedColour = 1
-- A sugár csak a Paintable mappán belüli partokat találhatja el
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
if gameProcessed then
return -- a billentyű vagy a kattintás a chatbe vagy egy gombra ment
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
-- Kérünk, nem parancsolunk: hogy fessen-e, azt a szerver dönti el
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
A gameProcessed akkor true, ha a motor már feldolgozta ezt a bevitelt, általában a felületen: egy kattintás egy gombra, vagy egy szövegmezőbe, például a chatsorba gépelt billentyűk. Ennek az ellenőrzésnek köszönhetően egy üzenetbe gépelt Q betű nem váltja át a színt.
2. minta: a szervertől egy klienshez
A szerver a FireClient segítségével küld üzenetet egyetlen játékosnak. Az első argumentum a címzett Player, a kliensoldali kezelő pedig csak az utána jövő argumentumokat kapja meg. Ezt használd minden személyes dologra: értesítés, jutalomablak, hang, amelyet csak ennek a játékosnak kell hallania. Az átvezető jelenetekről szóló útmutató egy nagyobb, kidolgozott példa: a szerver dönti el, mikor látja a játékos az átvezető jelenetet, és a FireClient segítségével küldi el a képeit ennek az egy játékosnak, a kamerát pedig az eszköze mozgatja.
Ez a scriptpár üdvözlést mutat, amikor egy játékos belép. A LocalScript maga rak össze egy kis bannert, ezért nem kell GUI-t beállítanod.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local function welcome(player: Player)
-- Az első argumentum választja ki, melyik kliens kapja az üzenetet. Senki más nem látja.
notify:FireClient(player, `Welcome, {player.DisplayName}! Press Q to change colour.`)
end
Players.PlayerAdded:Connect(welcome)
-- A Studióban hamarabb beléphetsz, mint hogy ez a script csatlakozna, ezért mindenkit üdvözlünk, aki már itt van
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
-- Kis banner a képernyő tetején, kódból összerakva
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
-- Itt nincs player paraméter: a szerver már kiválasztotta, ki kapja az üzenetet
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 -- elrejtjük, ha nem váltotta fel egy újabb üzenet
label.Visible = false
end
end)
end)
A szerver a PlayerAdded eseménykor küldi el az üzenetet, ez pedig megtörténhet azelőtt, hogy ez a LocalScript bekötné a kezelőjét. Ez rendben van: a Roblox sorba állítja a kezelő megjelenése előtt érkezett RemoteEvent-üzeneteket, és sorrendben kézbesíti őket, amint a kezelő csatlakozik.
A kliensnek nem kell védekeznie a szerver ellen: az OnClientEvent eseményt csak szerveroldali kód indíthatja el. A message: string annotáció a típusellenőrzéshez kell; nem futásidejű ellenőrzés.
3. minta: a szervertől minden klienshez
A FireAllClients ugyanazt az üzenetet küldi el minden csatlakozott játékosnak. Nincs Player argumentuma, és minden kliens ugyanabban az OnClientEvent eseményben kapja meg az üzenetet, mint korábban, ezért a 2. minta NotifyClient scriptje már meg is jeleníti.
Ez a Script mindenkinek bejelenti, amikor egy játékos először érinti meg a célvonalat. Adj a Workspace-hez egy FinishLine nevű rögzített Partot, majd adj egy Scriptet a ServerScriptService-hez.
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 -- nem játékos, vagy már bejelentettük
end
finished[player] = true
-- Minden csatlakozott kliens lefuttatja az OnClientEvent kezelőjét ezzel a szöveggel
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
Egy exploiter bármilyen távolságból elsütheti a Touched eseményt a saját karakterére, de egy játékosonként egyszer megjelenő bejelentésnél ez ártalmatlan. Ha később jutalmat adsz a célba érésért, a kiadás előtt adj hozzá szerveroldali ellenőrzéseket, például a kör kezdete óta eltelt minimális időt.
A FireAllClients csak az abban a pillanatban csatlakozott játékosokhoz jut el. Aki egy másodperccel később lép be, már nem látja az üzenetet. Ez egyszeri pillanatokhoz megfelel, például egy bejelentéshez, egy robbanáseffekthez vagy egy hanghoz, de nem felel meg olyan állapothoz, mint a kör időzítője vagy a játék aktuális fázisa. Állapothoz állíts be a szerveren egy attribútumot, például ReplicatedStorage:SetAttribute("TimeLeft", 30), és a kliensen olvasd a GetAttribute és a GetAttributeChangedSignal("TimeLeft") segítségével. Az attribútumok minden klienshez replikálódnak, a később belépett játékosokhoz is.
RemoteFunction: amikor a kliensnek válasz kell
A RemoteEvent a „küldd el és felejtsd el” elven működik. A RemoteFunction várakoztatja a hívót: az InvokeServer szünetelteti az őt hívó kódot, amíg a szerver OnServerInvoke függvénye vissza nem ad egy értéket, majd átadja, amit az visszaadott. Akkor használd, ha a kliens nem tud válasz nélkül továbblépni, például „helyes volt ez a kód?”. Ha nem kell válasz, a Roblox a RemoteEventet ajánlja, mert az nem vár.
Példa: egy mező, ahová a játékosok promókódot írnak. A szerver tárolja a kódokat, ellenőrzi a szöveget, és két értéket ad vissza: sikerült-e, és a megjelenítendő üzenetet.
- A
ReplicatedStorage.Remotesmappába illessz be egyRedeemCodenevű RemoteFunctiont. - A StarterGui-ba illessz be egy
CodeGuinevű ScreenGui-t, bele pedig egyCodeBoxnevű TextBoxot. A méretét és a helyét ízlés szerint válaszd meg. - Add hozzá az alábbi Scriptet a ServerScriptService-hez, a LocalScriptet pedig a
CodeBox-ba.
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local redeemCode = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RedeemCode") :: RemoteFunction
-- A kódok a szerveren élnek, ahol egyetlen játékos sem tudja kiolvasni őket
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 } = {}
-- = jellel adjuk értékül. Az OnServerInvoke callback, nem esemény, amelyre Connecttel csatlakozunk.
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)
A ranglista útmutató Coins értékéhez ad hozzá. A felhasznált kódokat csak a játékos kilépéséig jegyzi meg, ezért ebben a formában a játékos újra beléphet, és ugyanazt a kódot újra beírhatja. Ha az érmék mentődnek, ez minden újbelépéskor ingyen érmét jelent: mielőtt élő játékban használnád, tárold minden játékos felhasznált kódjait a mentett adataival együtt egy adattárban.
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..."
-- Az InvokeServer szünetelteti ezt a függvényt, amíg a szerver callbackje vissza nem ad egy értéket.
-- A pcall nem hagyja leállni a LocalScriptet, ha a hívás nem sikerült.
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)
Egy RemoteFunctionnek pontosan egy szerveroldali callbackje van. Ha két script is beállítja az OnServerInvoke értékét ugyanazon a RemoteFunctionön, csak az utolsó működik.
Miért veszélyes az InvokeClient
A RemoteFunction a másik irányba is működik, a szerveren az InvokeClient, a kliensen az OnClientInvoke segítségével. A Roblox dokumentációja három komoly kockázatot sorol fel:
- Ha a kliens callbackje hibát dob, a szerver is hibát dob.
- Ha a játékos a hívás közben kilép, az
InvokeClienthibát dob. - Ha a kliens soha nem ad vissza értéket, a szerverscript örökké várni fog.
Egy módosított kliens a saját callbackjét irányítja, ezért egy csaló szándékosan előidézheti a harmadik esetet, és addig tarthatja fogva azt a szerverszálat, ameddig csak akarja. A játékos képernyőjének frissítéséhez a FireClient-et használd. Ha a szervernek tényleg információ kell a klienstől, küldj egy RemoteEventet, a kliens egy másik RemoteEventtel válaszoljon, a válasz hiányát pedig a szerveren kezeld szokásos esetként.
Ellenőrizz minden argumentumot a szerveren
Egy exploiter bármelyik RemoteEventet vagy RemoteFunctiont annyiszor hívhatja meg, ahányszor csak akarja, bármilyen argumentumokkal. Az egyetlen, amit nem tud meghamisítani, az első paraméter: az üzenetet küldő Player-t maga a Roblox adja hozzá. Mindent, ami utána jön, ellenőrizni kell, mielőtt a szerver cselekszik. A remote elrejtése vagy LocalScriptben való ellenőrzése hiábavaló, mert a csaló a saját kliensét irányítja.
| Ellenőrzés | A szerver kérdése | Példa |
|---|---|---|
| Típus | Ez az a típus, amire várok? Instance, nem pedig egy tábla, amelyet úgy raktak össze, hogy annak tűnjön? | typeof(part) == "Instance" and part:IsA("BasePart") |
| Tartomány | A szám véges, és a megengedett határok között van? A szöveg hossza ésszerű? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| Tulajdonjog | Ez a játékos birtokolja a tárgyat, van elég pénze, joga van ezzel az objektummal cselekedni? | A tárgy benne van az inventoryjában; a part a Paintable mappán belül van |
| Távolság | Elég közel van a játékos karaktere a világ szerveroldali másolatában? Hagyj egy kis tartalékot a lagra. | Legfeljebb 30 stud a parttól |
| Gyakoriság | Nem küld túl gyakran ez a játékos? | Játékosonkénti cooldown, vagy egy korlát, amely felhalmozza a hívásokat |
A NaN külön figyelmeztetést érdemel. Ez egy szám, ezért a type(x) == "number" átengedi, de minden vele végzett összehasonlítás false eredményt ad, és egy olyan ellenőrzés, mint az x < 0 or x > 100, egyenesen átengedi. A math.isfinite(x) elutasítja a NaN-t és mindkét végtelent.
Ne feledd a távolság-ellenőrzés korlátját. Minden kliens a saját karakterének fizikáját irányítja, ezért egy exploiter a hívás előtt a célhoz mozgathatja a karakterét. Az ellenőrzés ettől még megállítja a legegyszerűbb visszaélést, amikor egy helyből az egész térképre hatnak. A célpartokat tartsd rögzítve: a Roblox biztonsági dokumentációja megjegyzi, hogy egy exploiter hálózati tulajdonjogot szerezhet a közelében lévő nem rögzített partok felett, és közelebb húzhatja őket, ez pedig megkerüli a távolság-ellenőrzést.
Íme ugyanezek az ellenőrzések egy ModuleScriptként, amelyet minden remote-kezelőben használhatsz.
local Players = game:GetService("Players")
local RemoteGuard = {}
-- Valódi szám min és max között. Elutasítja a NaN-t és a végtelent, amelyek átmennek
-- a szokásos type(x) == "number" ellenőrzésen.
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
-- Egész szám min és max között, mennyiségekhez, indexekhez és számlálókhoz
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
-- Szöveg hosszkorláttal. Az utf8.len nil-t ad vissza az érvénytelen UTF-8-ra, amelyet
-- az adattárak elutasítanak.
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
-- A várt osztályú Instance egy általad engedélyezett tárolón belül.
-- Egy Instance-nak tűnő, összerakott tábla nem megy át a typeof ellenőrzésen.
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, ha a játékos karaktere legfeljebb maxDistance studra van a position ponttól
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
-- Játékosonkénti gyakoriságkorlát. Minden játékos egyszerre `burst` hívást tehet, és
-- másodpercenként `perSecond` hívást kap vissza. Egy függvényt ad vissza, amelyet
-- a munka előtt kell meghívni: true-t (mehet) vagy false-t (túl gyakori) válaszol.
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
Tartsd a ServerScriptService-ben. Az onnan származó kód soha nem jut el a kliensekhez, így senki sem olvassa el az ellenőrzéseidet.
És itt az 1. minta kezelője vele újraírva. Cseréld le a PaintServer tartalmát:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- A ":: any" csak a Luau szigorú típusellenőrzése miatt fontos; futásidőben semmit sem változtat
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-es sorozat, utána 4 másodpercenként
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)
A korlátozó törli a játékos bejegyzését, amikor kilép, így a táblája nem nő a szerver teljes élettartama alatt.
A fegyvereknél ezek az ellenőrzések a legfontosabbak: soha ne engedd, hogy a kliens mondja meg, kit talált el. A kard útmutató remote-ja egyáltalán nem visz argumentumot, és a szerver maga találja meg a célpontokat. A fegyver útmutató csak a célzási pontot küldi el, amelyet a szerver típusra, NaN-ra és távolságra ellenőriz, mielőtt kilőné a saját sugarát.
A menükre ugyanez a szabály vonatkozik: a választást küldd el, ne az eredményt. Az NPC párbeszéd útmutatóban a kliens csak a megnyomott gomb számát küldi el, a szerver pedig maga nézi meg, mit ad ez a válasz. A teleport útmutató menüje a pont nevét küldi el, nem a pozícióját, és a szerver megkeresi a pontot a saját mappájában, és ellenőrzi, hány Win kell hozzá.
Mit lehet és mit nem lehet elküldeni
Átküldhetsz számokat, stringeket, logikai értékeket, Roblox típusokat, például Vector3, CFrame, Color3 és Enum elemeket, olyan Instance-okat, amelyeket mindkét oldal lát, és ezekből álló táblákat. Néhány érték útközben megváltozik vagy eltűnik:
| Amit elküldesz | Mi történik |
|---|---|
| Függvény | A másik oldal nil-t kap |
| Metatáblás tábla | A metatábla elvész, mindazzal együtt, ami a táblának csak rajta keresztül volt meg |
| Tábla vegyes szám- és stringkulcsokkal | A Roblox azt tanácsolja, ne csináld: tiszta tömböt vagy tiszta szótárat küldj |
Tábla benne lévő nil értékekkel | Kerüld: a Roblox semmilyen indexen nem javasolja a nil-t |
| Tábla Instance, userdata vagy function típusú kulcsokkal | Az ilyen kulcsok stringgé alakulnak |
| Instance, amelyet a fogadó nem lát, például a ServerStorage-ból vagy egy LocalScriptben létrehozott | A másik oldal nil-t kap |
| Bármilyen tábla | A fogadó másolatot kap, nem ugyanazt a táblát |
Jó szokás: azonosítókat küldj, ne objektumokat vagy értékeket. Egy tárgy nevét, egy lehetőség számát, egy partot, amelyet a szerver megtalálhat és ellenőrizhet. A szerver innen a saját adataival dolgozik.
Miért ad vissza nil-t a RemoteFunction
Ha az InvokeServer nil-t ad, menj végig ezeken a pontokon sorban:
- Visszatérési érték nélküli ág. Az
OnServerInvokeminden kilépési pontjának vissza kell adnia valamit. Egy korai ellenőrzésben lévő üresreturnnil-t küld vissza. - return egy beágyazott függvényen belül. A
pcall(function() ... end), egy:Connectkezelő vagy egytask.spawnbelsejében lévőreturncsak ebből a belső függvényből lép ki. Mentsd el az eredményt, példáullocal ok, data = pcall(...), majd adataértékét magából a callbackből add vissza. - Érték, amely nem tudja átlépni a határt. Egy függvény vagy egy Instance, amelyet a kliens nem lát (például bármi a ServerStorage-ban),
nil-ként érkezik. Bekapcsolt instance streaming mellett egy part, amelyet a szerver éppen létrehozott, a függvényből való visszatérés pillanatában lehet, hogy még nem jutott el a klienshez. - A callbacket egy másik script állította be. Csak az
OnServerInvokeutolsó értékadása működik. Keress rá a remote nevére a scriptjeidben.
Ha a hívás egyáltalán nem tér vissza, akkor egyetlen script sem állította még be az OnServerInvoke értékét (a Roblox sorban tartja a hívásokat, amíg be nem állítják), vagy a callback lefagyott, például egy WaitForChild-on valamire, ami soha nem jelenik meg.
UnreliableRemoteEvent: folyamatos, eldobható frissítésekhez
Az UnreliableRemoteEventnek ugyanazok a metódusai és eseményei vannak, mint a RemoteEventnek: FireServer, FireClient, FireAllClients, OnServerEvent és OnClientEvent. A különbség az, hogy a Roblox sem a kézbesítést, sem a sorrendet nem garantálja. Egy üzenet újraküldés nélkül eldobható, ha:
- útközben elvész, vagy túl sokáig vár egy túlterhelt hálózaton
- az adatai nagyobbak 1000 bájtnál
- a kliens a korlátnál gyakrabban küld (a többlet eldobódik, nem késleltetődik)
- az érkezés pillanatában egyetlen kezelő sincs bekötve (eldobódik, nem kerül sorba)
Az üzenetek rossz sorrendben is érkezhetnek, és a sorrendjüknek semmi köze a RemoteEventjeidhez vagy RemoteFunctionjeidhez. Akkor használd, ha csak a legfrissebb érték számít, és a következő frissítés a másodperc törtrésze alatt megérkezik: hová céloz a játékos, egy kozmetikai effekt pozíciója, egy minden képkockában változó érték. Ha a sorrend fontos, tegyél minden üzenetbe sorszámot vagy időbélyeget, és hagyj figyelmen kívül mindent, ami régebbi az utoljára feldolgozottnál.
Soha ne használd olyasmire, aminek pontosan egyszer kell megtörténnie, például vásárlásra, sebzésre, jutalomra vagy a kör indítására. Az argumentumait pedig ugyanúgy ellenőrizd a szerveren, mint a RemoteEventnél.
Kézbesítési sorrend és gyakoriságkorlátok
A Roblox kézbesítési garanciái egy kapcsolatra és egy irányra vonatkoznak: a szervertől egy kliensig, vagy egy klienstől a szerverig.
- A RemoteEventek megbízhatók és sorrendhelyesek. Az elveszett üzeneteket a rendszer újraküldi, amíg a fogadó kapcsolatban marad, és az üzenetek abban a sorrendben érkeznek, amelyben elküldted őket, még különböző RemoteEventeken keresztül is. Ha a szerver A-t, aztán B-t, aztán A-t küld egy játékosnak, az a játékos A, B, A sorrendben kapja meg őket.
- A sorrend a kezelők indításának pillanatára vonatkozik. Ha egy kezelő átadja a vezérlést, például egy
task.waitvagyWaitForChildhívással, a következő üzenet feldolgozása elkezdődhet, mielőtt az első véget érne. - A RemoteFunctionök és a RemoteEventek nincsenek egymáshoz képest sorrendben. Ha a kódod szigorú sorrendtől függ, az összetartozó üzeneteket egyféle remote-on keresztül küldd, vagy adj hozzá saját sorszámot.
- A tulajdonságok és attribútumok változásai nincsenek sorrendben a remote-okhoz képest. Ha a szerver módosít egy tulajdonságot, majd meghív egy remote-ot, a kliens bármelyiket láthatja előbb. Magát a változást figyeld, például a
GetPropertyChangedSignalsegítségével, és ne számíts arra, hogy már megérkezett. - Még nincs kezelő. A RemoteEvent-üzenetek sorban állnak, amíg egy kezelő nem csatlakozik. A sornak vannak korlátai: amikor megtelik, a következő üzenetek eldobódnak, az Outputban pedig megjelenik a
Remote event invocation discardedhiba. - A kilépő játékos elveszít minden üzenetet, amely még nem jutott el hozzá.
Gyakoriságkorlát. A klienstől a szerverhez küldött RemoteEvent- és UnreliableRemoteEvent-üzenetek nagyjából kliensenként másodpercenként 500 kérésre vannak korlátozva, a dokumentáció 2026. szeptember 30-i állapota szerint. A korlát az azonos típusú remote-ok között közös, ezért egy terhelt remote tízre bontása nem emeli meg. A korlát felett a RemoteEvent-üzenetek később kerülnek feldolgozásra, és megtartják a sorrendjüket, az UnreliableRemoteEvent-üzenetek viszont eldobódnak. A motor korlátja semmiben sem akadályozza meg, hogy egy játékos másodpercenként 50-szer hívja a remote-odat, ezért minden kezelőnek, amely valamit megváltoztat, ettől még saját játékosonkénti korlát kell.
RemoteEvent, RemoteFunction, UnreliableRemoteEvent vagy attribútum?
| Használd | Mire | Példa | Mire figyelj |
|---|---|---|---|
| RemoteEvent | Egyirányú üzenetek, amelyeknek meg kell érkezniük, és sorrendben | Kliens: „fesd ki ezt a partot”. Szerver: „mutasd meg ezt az értesítést” | Minden argumentumot ellenőrizz a szerveren |
RemoteFunction az InvokeServer-rel | A kliensnek válasz kell, mielőtt továbbléphetne | Promókód beírása, vásárlás megerősítése | A hívó vár; minden ágnak értéket kell visszaadnia |
RemoteFunction az InvokeClient-tel | Szinte soha | Helyette használd a FireClient-et | Egy kliens, amelynél hiba történt, amely kilépett vagy nem válaszolt, elrontja vagy megakasztja a hívást a szerveren |
| UnreliableRemoteEvent | Gyakori frissítések, ahol csak az utolsó számít | Célzási irány, kozmetikai effektek | Az üzenetek elvesznek vagy felcserélődnek; 1000 bájtos adatkorlát |
| A szerver által beállított attribútum vagy value objektum | Közös állapot, amelynek mindig látszania kell, a később belépett játékosoknak is | A kör időzítője, a játék fázisa, nyitva van-e egy ajtó | Mindenkihez csak a szerver változtatásai jutnak el; a kliensek a GetAttributeChangedSignal vagy a Changed segítségével figyelnek |
| BindableEvent | Az egy oldalon lévő scriptek kommunikációja | Egy szerverscript szól egy másiknak, hogy vége a körnek | Nem lép át a szerver és a kliens között |
Egy teljes példát arra, hogyan működnek együtt a RemoteFunctionök és az ellenőrzések ott, ahol a játékosok fizetnek, a hogyan készíts bolt GUI-t útmutatóban találsz. Ami az attribútumos sort illeti, az ajtó útmutató szerverscriptje minden ajtón beállítja az Open attribútumot minden mozgásakor, így bármelyik LocalScript reagálhat rá.
Gyakori hibák és megoldásaik
A remote-okkal kapcsolatos problémák többsége látszik az Output ablakban (a Window menüből vagy a Script fülről nyisd meg). Először ott nézz körül, aztán keresd meg alább a tünetedet. A script hibákról szóló útmutató részletesebben tárgyalja az általános hibaüzeneteket.
Infinite yield possible egy remote WaitForChild hívásánál
A script egy olyan remote-ra vár, amely soha nem jelenik meg. Ellenőrizd, hogy a név és a kis- és nagybetűk pontosan egyeznek-e, és hogy a remote a ReplicatedStorage-ban van-e, nem a ServerStorage-ban vagy a ServerScriptService-ben, amelyeket a kliensek nem látnak.
A szerver rossz értékeket kap, eggyel elcsúszva
A LocalScript magát a játékost is átadta, mint a remote:FireServer(player, 5) hívásban. A Roblox amúgy is hozzáadja a küldőt első paraméterként, ezért a szerver (player, player, 5)-öt lát. Hívd így: remote:FireServer(5).
Semmi sem történik, amikor meghívom a remote-ot
Ellenőrizd, hogy minden hívás a megfelelő oldalról megy-e: a FireServer és az InvokeServer csak kliensoldali kódból működik, a FireClient, a FireAllClients és az InvokeClient pedig csak szerveroldali Scriptből. Egy LocalScript soha nem fut a ServerScriptService-ben, a ServerStorage-ban vagy közvetlenül a Workspace-ben; tedd a StarterPlayerScripts, a StarterGui, a StarterCharacterScripts vagy a StarterPack alá. Ezután keress az Outputban hibát a kezelőn belül.
Remote event invocation discarded
Üzenetek érkeztek egy olyan RemoteEventhez, amelyhez nem volt kezelő bekötve, és a sor megtelt. Általában a kezelőt tartalmazó script hibával leáll a :Connect sor előtt, ki van kapcsolva, vagy beragadt, mert valamire vár, ami soha nem töltődik be. A kezelőket a script elejéhez közel kösd be.
Nálam működik, de a többi játékos nem látja a változást
A változtatás a kliensen történt, egy LocalScriptben vagy egy OnClientEvent kezelőben. Csináld meg a szerver OnServerEvent kezelőjében.
Az InvokeServer soha nem tér vissza
Vagy egyetlen script sem állította be az OnServerInvoke értékét (a Roblox sorban tartja a hívásokat, amíg be nem állítják), vagy a callback beragadt valamin, ami átadja a vezérlést, például egy WaitForChild-on vagy egy adattár-kérésen. Tegyél egy print-et a callback elejére és végére, hogy lásd, hol áll meg.
Elkészítés RoCode-dal
Ezt a RoCode is beállíthatja, közvetlenül a nálad nyitott place-ben. A RoCode egy AI-ügynök, amely egy Roblox Studio pluginon keresztül dolgozik, ezért a remote-okat és a scripteket az Explorerben hozza létre, ahelyett hogy beillesztendő kódot adna.
A játékosok kattintással fessék ki a Paintable mappa partjait. Használj RemoteEventet, és az ellenőrzéseket hagyd a szerveren: csak ennek a mappának a partjai, legfeljebb 30 stud, és másodpercenként legfeljebb néhány festés.
- Általában először átnézi a place-t a Search Game és a Search Scripts eszközzel, meglévő Remotes mappát vagy kezelőt keresve, és a te mappáidat használja, ha vannak
- A Create Instance eszközzel létrehozza a RemoteEventet a ReplicatedStorage-ban, a szerveroldali Scriptet és a LocalScriptet pedig a Create Script eszközzel írja meg
- Befejezés előtt minden script fordítását ellenőrzi a Check Scripttel a Studióban. Ez a fordítási hibákat kapja el, nem a logikai hibákat: nem ellenőriz típusokat, nem futtat lintert, és nem hajtja végre a kódodat
- A módosításokat csomagokban küldi, és minden csomag egy visszavonási pont a Studio előzményeiben
3.9-es vagy újabb pluginnal a RoCode rövid játéktesztet indíthat és kiolvashatja a hibákat, 3.9.11-es vagy újabb pluginnal pedig irányíthat egy tesztkaraktert, de a 3D-ablakban lévő partokra nem kattint. Nyomd meg te a Play gombot, és próbáld kijátszani az ellenőrzéseket, például úgy, hogy a térkép másik végéről festesz ki egy partot. Ha hiba történt, a Check Output kiolvashatja az utolsó játékteszted Server és Client sorait. A legtöbb játékrendszer ilyen remote-okon keresztül kommunikál, ezért újra találkozol velük, amikor rendszerről rendszerre építed a játékot a RoCode-dal. Hogyan csatlakozik a RoCode a Studióhoz.
Gyakori kérdések
Mit jelent a securing the client-server boundary a Robloxban?
Így hívják a Roblox dokumentációjának a remote-ok biztonságáról szóló oldalát, és az ötlet egyszerű: minden, amit a kliens RemoteEventen vagy RemoteFunctionön keresztül küld, egy exploitertől is származhat, ezért a szerver ellenőrzi, mielőtt cselekedne. Ellenőrizd minden argumentum típusát, tartsd a számokat ésszerű határok között, ellenőrizd, hogy a játékosnak most szabad-e ezt tennie, és korlátozd, milyen gyakran hívhatja egy játékos a remote-ot. A fenti ellenőrzőlista mindegyiket kódban is megmutatja.
Biztonságos a RemoteFunction használata?
Az InvokeServer pontosan annyira biztonságos, amennyire a szerveroldali callbacked: ellenőrizd az argumentumait, és korlátozd a gyakoriságot, ahogy bármely RemoteEventnél. A kockázatos irány az InvokeClient, mert egy kliens, amelynél hiba történt, amely kilépett, vagy amely soha nem adott vissza értéket, elrontja vagy megakasztja a hívást a szerveren.
Láthatják és meghívhatják az exploiterek a remote-jaimat?
Igen. Minden, ami a ReplicatedStorage-ban van, eljut minden klienshez, egy módosított kliens pedig bármelyik remote-ot meghívhatja bármilyen argumentumokkal. A remote-ok átnevezése vagy elrejtése nem teszi őket biztonságossá; minden argumentum szerveroldali ellenőrzése teszi őket azzá.
Küldhet egy kliens RemoteEventet egy másik kliensnek?
Közvetlenül nem. Küldd el a szervernek, ott ellenőrizd, majd használd a FireClient-et vagy a FireAllClients-t.
Milyen gyakran lehet meghívni egy RemoteEventet?
A Roblox dokumentációja kliensenként nagyjából másodpercenként 500 kéréses korlátot ad meg a szerverhez küldött RemoteEvent- és UnreliableRemoteEvent-üzenetekre, amely az azonos típusú remote-ok között közös. Maradj jóval alatta, és adj minden kezelőnek saját játékosonkénti korlátot.
Eljut a FireAllClients a később belépett játékosokhoz?
Nem. Az abban a pillanatban csatlakozott játékosokhoz jut el. Olyan állapothoz, amelyre a később érkezőknek is szükségük van, állíts be a szerveren egy attribútumot vagy value objektumot.
Mi a különbség a RemoteEvent és a BindableEvent között?
A RemoteEvent átlép a szerver és a kliens között. A BindableEvent az egy oldalon lévő scripteket köti össze, például két szerverscriptet.
Források és további olvasnivaló
- Roblox Creator Docs: Remote events and callbacks (angolul). FireServer, FireClient, InvokeServer, az InvokeClient kockázatai, az argumentumok korlátai és a kézbesítési garanciák
- Roblox Creator Docs: Securing the client-server boundary (angolul). Az ellenőrzés szintjei, NaN, gyakoriságkorlátok, továbbítás kliensről kliensre
- Roblox Creator Docs: Security and cheat mitigation tactics (angolul). Mire képes egy módosított kliens, és a szerver tekintélye
- Roblox Creator Docs: Network ownership, movement validation, and physics (angolul). Miért irányítja a kliens a saját karakterét, és a távolság-ellenőrzések korlátai
- Roblox Engine API: RemoteEvent (angolul). Gyakoriságkorlát és az invocation discarded hiba
- Roblox Engine API: RemoteFunction (angolul). OnServerInvoke, figyelmeztetések az InvokeClientről és óvintézkedések streaming mellett
- Roblox Engine API: UnreliableRemoteEvent (angolul). Az 1000 bájtos adatkorlát
- Roblox Creator Docs: Properties and attributes (angolul). A replikáció sorrendje a tulajdonságváltozások és a remote eventek között
Hogyan ellenőriztük a kódot: az oldalon minden script átmegy a Luau szigorú típusellenőrzésén a Roblox API definícióival (luau-lsp, 2026. november 20.). A típusellenőrzés kiszűri az elírt API-neveket és a rossz típusokat, de a játéklogikai hibákat nem, ezért publikálás előtt mindent tesztelj a Studióban.