Útmutató · Scriptelési alapok

RemoteEvent Robloxban: a klienstől a szerverig és vissza

Egy LocalScript nem tudja megváltoztatni, amit a többi játékos lát, egy szerveroldali Script pedig nem ér el egyetlen játékos képernyőjéig. A kettő között a RemoteEventek viszik az üzeneteket. Ebben az útmutatóban összerakjuk azt a három mintát, amelyre a leggyakrabban szükséged lesz, egy RemoteFunctiont, amely választ ad vissza, és azokat a szerveroldali ellenőrzéseket, amelyek megakadályozzák, hogy egy módosított kliens visszaéljen velük.

Frissítve 2026. november 20.18 perc olvasásSzerző:

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 és OnServerInvoke) csak akkor használd, ha a kliensnek válasz kell. Kerüld az InvokeClient-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
  1. Mire valók a remote-ok
  2. A remote-ok beállítása
  3. 1. A klienstől a szerverhez
  4. 2. A szervertől a klienshez
  5. 3. A szervertől mindenkihez
  6. RemoteFunction
  7. Ellenőrzőlista
  8. Amit nem lehet elküldeni
  9. Nil-t ad vissza?
  10. UnreliableRemoteEvent
  11. Sorrend és korlátok
  12. Mit válassz
  13. Common errors
  14. RoCode-dal
  15. Gyakori kérdések
  16. Források és további olvasnivaló

Mire valók a RemoteEventek

IllusztrációMinden kattintás arra kéri a szervert, hogy fesse át a partot, ezért az új szín mindkét játékos képernyőjén látszik.

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ó.
Melyik hívás melyik eseményt indítja
IrányA küldő meghívjaA fogadó erre csatlakozikA fogadó megkapja
A klienstől a szerverhezremote:FireServer(...) egy LocalScriptbenremote.OnServerEvent egy ScriptbenAz üzenetet küldő Player, majd a te argumentumaid
A szervertől egy klienshezremote:FireClient(player, ...) egy Scriptbenremote.OnClientEvent egy LocalScriptbenCsak a te argumentumaid
A szervertől minden klienshezremote:FireAllClients(...) egy Scriptbenremote.OnClientEvent egy LocalScriptbenCsak a te argumentumaid
A kliens kérdez, a szerver válaszolremoteFunction: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.

  1. Az Explorerben vidd a kurzort a ReplicatedStorage fölé, kattints a + gombra, és illessz be egy Foldert. Nevezd el a mappát Remotes néven.
  2. Vidd a kurzort a Remotes fölé, kattints a + gombra, és illessz be egy RemoteEventet. Nevezd át úgy, hogy a neve leírja a célját, például PaintRequest.
  3. Ismételd meg minden remote-nál. Ez az útmutató két RemoteEventet (PaintRequest és Notify) és egy RemoteFunctiont (RedeemCode) használ.
Az Explorer: minden, amit ez az útmutató hozzáad, részről részre
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.

  1. A Workspace-be illessz be egy Paintable nevű Foldert, és tegyél bele néhány rögzített Partot.
  2. Ellenőrizd, hogy a ReplicatedStorage.Remotes mappában van-e egy PaintRequest nevű RemoteEvent.
  3. Illessz be egy PaintServer nevű Scriptet a ServerScriptService-be és egy PaintClient nevű LocalScriptet a StarterPlayer, StarterPlayerScripts helyre, az alábbi kóddal.
Script helye: ServerScriptService neve: 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")

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

LocalScript helye: StarterPlayerScripts neve: 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 -- 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.

Script helye: ServerScriptService neve: WelcomeServer
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
LocalScript helye: StarterPlayerScripts neve: NotifyClient
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.

Script helye: ServerScriptService neve: 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 -- 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.

  1. A ReplicatedStorage.Remotes mappába illessz be egy RedeemCode nevű RemoteFunctiont.
  2. A StarterGui-ba illessz be egy CodeGui nevű ScreenGui-t, bele pedig egy CodeBox nevű TextBoxot. A méretét és a helyét ízlés szerint válaszd meg.
  3. Add hozzá az alábbi Scriptet a ServerScriptService-hez, a LocalScriptet pedig a CodeBox-ba.
Script helye: ServerScriptService neve: RedeemServer
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.

LocalScript helye: TextBox CodeBox neve: 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..."

	-- 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 InvokeClient hibá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őlista a szervernek
EllenőrzésA szerver kérdésePélda
TípusEz 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ányA 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
TulajdonjogEz 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ágElé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ágNem 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.

ModuleScript helye: ServerScriptService neve: RemoteGuard
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:

Script helye: ServerScriptService neve: PaintServer
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:

Argumentumok, amelyek nem úgy érkeznek meg, ahogy elküldted őket
Amit elküldeszMi történik
FüggvényA másik oldal nil-t kap
Metatáblás táblaA metatábla elvész, mindazzal együtt, ami a táblának csak rajta keresztül volt meg
Tábla vegyes szám- és stringkulcsokkalA 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ékekkelKerüld: a Roblox semmilyen indexen nem javasolja a nil-t
Tábla Instance, userdata vagy function típusú kulcsokkalAz ilyen kulcsok stringgé alakulnak
Instance, amelyet a fogadó nem lát, például a ServerStorage-ból vagy egy LocalScriptben létrehozottA másik oldal nil-t kap
Bármilyen táblaA 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:

  1. Visszatérési érték nélküli ág. Az OnServerInvoke minden kilépési pontjának vissza kell adnia valamit. Egy korai ellenőrzésben lévő üres return nil-t küld vissza.
  2. return egy beágyazott függvényen belül. A pcall(function() ... end), egy :Connect kezelő vagy egy task.spawn belsejében lévő return csak ebből a belső függvényből lép ki. Mentsd el az eredményt, például local ok, data = pcall(...), majd a data értékét magából a callbackből add vissza.
  3. É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.
  4. A callbacket egy másik script állította be. Csak az OnServerInvoke utolsó é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.wait vagy WaitForChild hí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 GetPropertyChangedSignal segí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 discarded hiba.
  • 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?

Hogyan válaszd ki a kliens és a szerver közötti kommunikáció módját
HasználdMirePéldaMire figyelj
RemoteEventEgyirányú üzenetek, amelyeknek meg kell érkezniük, és sorrendbenKliens: „fesd ki ezt a partot”. Szerver: „mutasd meg ezt az értesítést”Minden argumentumot ellenőrizz a szerveren
RemoteFunction az InvokeServer-relA kliensnek válasz kell, mielőtt továbbléphetnePromókód beírása, vásárlás megerősítéseA hívó vár; minden ágnak értéket kell visszaadnia
RemoteFunction az InvokeClient-telSzinte sohaHelyette használd a FireClient-etEgy kliens, amelynél hiba történt, amely kilépett vagy nem válaszolt, elrontja vagy megakasztja a hívást a szerveren
UnreliableRemoteEventGyakori frissítések, ahol csak az utolsó számítCélzási irány, kozmetikai effektekAz üzenetek elvesznek vagy felcserélődnek; 1000 bájtos adatkorlát
A szerver által beállított attribútum vagy value objektumKözös állapot, amelynek mindig látszania kell, a később belépett játékosoknak isA 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
BindableEventAz egy oldalon lévő scriptek kommunikációjaEgy szerverscript szól egy másiknak, hogy vége a körnekNem 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.

Te írod

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.

A RoCode elvégzi
  • Á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ó

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.

Próbáld ki a RoCode-ot a saját játékodban.

Ingyenes kreditek minden nap, bankkártya nélkül. Telepítsd a plugint, írd le a funkciót, és nézd meg, mi jelenik meg a Studióban.