מדריך · יסודות הסקריפטים

RemoteEvent ב-Roblox: מהלקוח לשרת ובחזרה

LocalScript לא יכול לשנות את מה ששחקנים אחרים רואים, ו-Script של שרת לא יכול להגיע למסך של שחקן אחד. את ההודעות ביניהם מעבירים RemoteEvents. במדריך הזה נבנה את שלוש התבניות שתצטרכו הכי הרבה, RemoteFunction שמחזירה תשובה, ובדיקות שרת שלא נותנות ללקוח מתוקן לנצל אותן לרעה.

עודכן 20 בנובמבר 202615 דק׳ קריאהמאת:

בקצרה

RemoteEvent הוא אובייקט שבדרך כלל נמצא ב-ReplicatedStorage ומעביר הודעות דרך הגבול בין הלקוח לשרת. LocalScript קורא ל-FireServer, והשרת מקבל את ההודעה ב-OnServerEvent, שבו נוסף כארגומנט ראשון ה-Player ששלח אותה. השרת קורא ל-FireClient(player, ...) או ל-FireAllClients(...), ו-LocalScripts מקבלים את ההודעה ב-OnClientEvent.

  • השתמשו ב-RemoteFunction (InvokeServer ו-OnServerInvoke) רק כשהלקוח צריך תשובה. הימנעו מ-InvokeClient: לקוח שקרתה אצלו שגיאה, שיצא או שאף פעם לא החזיר ערך, שובר את הקריאה בשרת.
  • אף פעם אל תסמכו על מה שהלקוח שולח. בשרת בדקו את הסוג, הטווח והבעלות של כל ארגומנט, את המרחק לשחקן, וכמה פעמים הוא קורא ל-remote.
  • פונקציות, מטא-טבלאות ואובייקטים שהצד השני לא רואה לא שורדים את ההעברה. UnreliableRemoteEvent יכול לאבד הודעות או לשנות את הסדר שלהן, וזורק כל נתון שגדול מ-1000 בתים.
בעמוד הזה
  1. למה צריך remotes
  2. הגדרת remotes
  3. 1. מהלקוח לשרת
  4. 2. מהשרת ללקוח
  5. 3. מהשרת לכולם
  6. RemoteFunction
  7. רשימת בדיקות
  8. מה אי אפשר לשלוח
  9. מחזירה nil?
  10. UnreliableRemoteEvent
  11. סדר ומגבלות
  12. מה לבחור
  13. Common errors
  14. עם RoCode
  15. שאלות נפוצות
  16. מקורות וקריאה נוספת

למה צריך RemoteEvents

איורכל לחיצה מבקשת מהשרת לצבוע Part, ולכן הצבע החדש נראה במסכים של שני השחקנים.

כל משחק Roblox עובד כשרת אחד ועוד לקוח אחד לכל שחקן. השרת כאן הבוס: אובייקט חדש או שינוי מאפיין מגיעים לכל השחקנים רק כשהשרת עושה אותם. שינוי שנעשה ב-LocalScript נשאר במכשיר אחד, חוץ מכמה חריגים כמו הדמות של השחקן עצמו, שהלקוח שלו שולט בתנועה שלה. לכן כשלחיצה או מקש צריכים לשנות את העולם המשותף, הלקוח צריך לבקש מהשרת, וכשהשרת רוצה שהמסך של שחקן אחד יגיב, הוא צריך להודיע על זה ללקוח. אם ההפרדה בין Script ל-LocalScript חדשה לכם, קראו קודם את Script vs LocalScript vs ModuleScript (באנגלית). אם הסקריפטים עצמם חדשים לכם, התחילו מאיך כותבים סקריפטים ב-Roblox Studio.

כדי לחצות את הגבול הזה Roblox נותנת שלושה אובייקטים:

  • RemoteEvent: הודעה לכיוון אחד. השולח ממשיך מיד בעבודה.
  • RemoteFunction: בקשה שמחכה לתשובה. הקוד שקרא עומד בהשהיה עד שהצד השני מחזיר ערך.
  • UnreliableRemoteEvent: הודעה לכיוון אחד שעלולה ללכת לאיבוד או להגיע לא לפי הסדר, אבל מעמיסה פחות על הרשת. מתאים לנתונים שמשתנים כל הזמן.
איזו קריאה מפעילה איזה אירוע
כיווןהשולח קורא להמקבל מתחבר להמקבל מקבל
מהלקוח לשרתremote:FireServer(...) ב-LocalScriptremote.OnServerEvent ב-Scriptה-Player ששלח את ההודעה, ואחריו הארגומנטים שלכם
מהשרת ללקוח אחדremote:FireClient(player, ...) ב-Scriptremote.OnClientEvent ב-LocalScriptרק הארגומנטים שלכם
מהשרת לכל הלקוחותremote:FireAllClients(...) ב-Scriptremote.OnClientEvent ב-LocalScriptרק הארגומנטים שלכם
הלקוח שואל, השרת עונהremoteFunction:InvokeServer(...)remoteFunction.OnServerInvoke = function(player, ...)Player, ואחריו הארגומנטים שלכם. מי שקרא מקבל את מה שהפונקציה החזירה

לקוחות לא יכולים לשלוח הודעות זה לזה ישירות. כדי להעביר משהו משחקן אחד לשאר, שלחו אותו לשרת, בדקו שם, ותנו לשרת להעביר הלאה דרך FireClient או FireAllClients. לפי המלצות האבטחה של Roblox, השרת כאן עובד כשומר סף, לא כממסר פשוט.

איפה שומרים remotes

remote צריך להיות במקום שבו גם השרת וגם הלקוחות רואים אותו. המקום הרגיל הוא ReplicatedStorage; בתיעוד של Roblox מצוין שבחלק מהמקרים מתאימים גם Workspace או Tool. ServerStorage ו-ServerScriptService זמינים רק לשרת, ולכן LocalScript שמחכה ל-remote משם יחכה לנצח.

  1. ב-Explorer רחפו מעל ReplicatedStorage, לחצו על כפתור ה-+ והכניסו Folder. קראו לתיקייה Remotes.
  2. רחפו מעל Remotes, לחצו על + והכניסו RemoteEvent. שנו את השם שלו כך שיתאר את המטרה, למשל PaintRequest.
  3. חזרו על זה לכל remote. במדריך הזה משתמשים בשני RemoteEvents (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

הסקריפטים במדריך הזה מוצאים remotes דרך WaitForChild. הוא מחזיר תוצאה מיד אם ה-remote כבר במקום, ומחכה אם הוא עוד לא קיים, למשל כשסקריפט שרת יוצר remotes בזמן המשחק. צרו remote נפרד לכל סוג בקשה: אז כל handler בשרת בודק צורת ארגומנטים אחת, והרבה יותר קל לעשות את זה נכון מאשר עם remote אחד לכל המקרים.

תבנית 1: מהלקוח לשרת, עם בדיקה בשרת

המשימה הכי נפוצה: שחקן עושה משהו במסך שלו, והשרת מחליט מה יקרה. כאן השחקן לוחץ על Q כדי לבחור אחד מארבעה צבעים, ולוחץ או מקיש על Part כדי לצבוע אותו. את הצבע החדש רואים כולם, כי השרת צובע.

הלקוח שולח שני דברים: איזה Part ואת המספר של הצבע. את הצבע עצמו הוא אף פעם לא שולח, ובמשחקים אחרים הוא באותה מידה לא אמור לשלוח מחיר, פרס או גודל נזק. לקוח מתוקן יכול לשלוח כל דבר, ולכן את הנתונים האמיתיים (כאן זו הפלטה) שומר השרת, ואת הארגומנטים הוא רואה כבקשה שצריך לבדוק.

  1. ב-Workspace הכניסו Folder בשם Paintable ושימו בו כמה Parts מעוגנים.
  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 -- studs בין הדמות ל-Part
local COOLDOWN_SECONDS = 0.25

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

-- הפרמטר הראשון הוא תמיד השחקן שקרא ל-remote. Roblox מכניסה אותו,
-- ולכן אפשר לסמוך עליו. כל מה שאחריו הגיע מהלקוח, ועל זה אסור לסמוך.
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
	-- 1. סוג: Part אמיתי, לא טבלה שמתחזה לו
	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. מטרה מותרת: רק Parts בתיקייה Paintable, שום דבר אחר במשחק
	if not part:IsDescendantOf(paintable) then
		return
	end

	-- 4. מרחק: הדמות של השחקן צריכה להיות ליד ה-Part
	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

-- הקרן יכולה לפגוע רק ב-Parts בתוך התיקייה 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 שאליו היא מיועדת, וה-handler בלקוח מקבל רק את הארגומנטים שאחריו. השתמשו בזה לכל דבר אישי: התראה, חלון עם פרס, צליל שרק השחקן הזה צריך לשמוע. המדריך לסצנות קולנועיות הוא דוגמה גדולה יותר שמפורטת: השרת מחליט מתי השחקן יראה סצנה ושולח את השוטים שלה לשחקן האחד הזה דרך 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 הזה מחבר את ה-handler שלו. זה בסדר: Roblox מכניסה לתור הודעות RemoteEvent שהגיעו לפני שה-handler הופיע, ומוסרת אותן לפי הסדר ברגע שה-handler מתחבר.

הלקוח לא צריך להתגונן מפני השרת: להפעיל את 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

	-- כל לקוח מחובר מריץ את ה-handler של OnClientEvent שלו עם הטקסט הזה
	notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)

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

אקספלויטר יכול להפעיל Touched לדמות שלו מכל מרחק, אבל להכרזה שמוצגת פעם אחת לכל שחקן זה לא מזיק. אם אחר כך תתנו פרס על הסיום, הוסיפו בדיקות שרת לפני הנתינה, למשל זמן מינימלי מתחילת הסיבוב.

FireAllClients מגיע רק לשחקנים שמחוברים באותו רגע. מי שנכנס שנייה אחר כך כבר לא יראה את ההודעה. זה מתאים לרגעים חד-פעמיים, כמו הכרזה, אפקט פיצוץ או צליל, אבל לא מתאים למצב כמו טיימר סיבוב או השלב הנוכחי במשחק. למצב, קבעו בשרת Attribute, למשל ReplicatedStorage:SetAttribute("TimeLeft", 30), וקראו אותו בלקוח דרך GetAttribute ו-GetAttributeChangedSignal("TimeLeft"). Attributes משוכפלים לכל לקוח, כולל שחקנים שנכנסו מאוחר יותר.

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 הוא callback, לא אירוע שעושים לו 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 משהה את הפונקציה הזו עד שה-callback של השרת מחזיר ערך.
	-- 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 יש בדיוק callback אחד בשרת. אם שני סקריפטים קובעים OnServerInvoke לאותה RemoteFunction, עובד רק האחרון.

למה InvokeClient מסוכן

RemoteFunction עובדת גם בכיוון ההפוך, עם InvokeClient בשרת ו-OnClientInvoke בלקוח. התיעוד של Roblox מונה שלושה סיכונים רציניים:

  • אם ה-callback של הלקוח זורק שגיאה, גם השרת זורק שגיאה.
  • אם השחקן יוצא בזמן הקריאה, InvokeClient זורק שגיאה.
  • אם הלקוח אף פעם לא מחזיר ערך, סקריפט השרת יחכה לנצח.

לקוח מתוקן שולט ב-callback שלו, ולכן רמאי יכול לגרום בכוונה למקרה השלישי ולהחזיק את ה-thread הזה בשרת כמה שירצה. כדי לעדכן את המסך של שחקן, השתמשו ב-FireClient. אם השרת באמת צריך מידע מהלקוח, שלחו RemoteEvent, תנו ללקוח לענות דרך RemoteEvent אחר, ובשרת התייחסו להיעדר תשובה כמקרה רגיל.

בדקו כל ארגומנט בשרת

אקספלויטר יכול להפעיל כל RemoteEvent או כל RemoteFunction כמה פעמים שירצה ועם כל ארגומנט. הדבר היחיד שהוא לא יכול לזייף הוא הפרמטר הראשון: Roblox בעצמה מכניסה את ה-Player ששלח את ההודעה. כל מה שבא אחריו צריך לבדוק לפני שהשרת מתחיל לפעול. להסתיר remote או לבדוק ב-LocalScript זה חסר תועלת, כי רמאי שולט בלקוח שלו.

רשימת בדיקות לשרת
בדיקההשאלה שהשרת שואלדוגמה
סוגזה הסוג שאני מצפה לו? Instance, ולא טבלה שנבנתה כך שתיראה כמוהו?typeof(part) == "Instance" and part:IsA("BasePart")
טווחהמספר סופי ונמצא בגבולות המותרים? לטקסט יש אורך סביר?math.isfinite(n), n >= 1 and n <= 4, #text <= 20
בעלותהשחקן הזה הבעלים של הפריט, יש לו מספיק כסף, יש לו הרשאה לפעול עם האובייקט הזה?הפריט נמצא במלאי שלו; ה-Part נמצא בתוך Paintable
מרחקהאם הדמות של השחקן קרובה מספיק בעותק העולם של השרת? השאירו מרווח קטן ל-lag.לא יותר מ-30 studs מה-Part
קצבהאם השחקן הזה לא שולח לעיתים קרובות מדי?זמן המתנה לשחקן או מגבלה עם צבירת קריאות

NaN מגיע לו אזהרה נפרדת. זה מספר, ולכן type(x) == "number" עובר, אבל כל השוואה איתו נותנת false, ובדיקה כמו x < 0 or x > 100 מעבירה אותו הלאה. math.isfinite(x) דוחה NaN ואת שני האינסופים.

זכרו את הגבול של בדיקת המרחק. כל לקוח שולט בפיזיקה של הדמות שלו, ולכן אקספלויטר יכול להזיז את הדמות למטרה לפני הקריאה. הבדיקה עדיין עוצרת את הניצול הכי פשוט, כשממקום אחד פועלים על כל המפה. השאירו את Parts המטרה מעוגנים: בתיעוד האבטחה של Roblox מצוין שאקספלויטר יכול לקבל בעלות ברשת על Parts לא מעוגנים לידו ולמשוך אותם קרוב יותר, וזה עוקף את בדיקת המרחק.

הנה אותן בדיקות בצורת ModuleScript, שאפשר להשתמש בו בכל handler של remote.

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 studs מ-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. קוד משם אף פעם לא מגיע ללקוחות, ולכן אף אחד לא יקרא את הבדיקות שלכם.

והנה ה-handler מתבנית 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)

המגביל מוחק את הרשומה של שחקן כשהוא יוצא, ולכן הטבלה שלו לא גדלה כל זמן החיים של השרת.

בנשק הבדיקות האלה הכי חשובות: אף פעם אל תתנו ללקוח להגיד במי פגעו. ה-remote מהמדריך לחרב בכלל לא נושא ארגומנטים, והשרת מוצא את המטרות בעצמו. המדריך לנשק שולח רק את נקודת הכוונון, שהשרת בודק לסוג, ל-NaN ולמרחק לפני שהוא יורה קרן משלו.

תפריטים כפופים לאותו כלל: שלחו בחירה, לא תוצאה. במדריך לדיאלוג עם NPC הלקוח שולח רק את מספר הכפתור שנלחץ, והשרת בעצמו בודק מה התשובה הזו נותנת. התפריט מהמדריך לטלפורטים שולח שם של נקודה, לא מיקום, והשרת מוצא את הנקודה בתיקייה שלו ובודק כמה Wins צריך בשבילה.

מה אפשר ומה אי אפשר לשלוח

אפשר להעביר מספרים, מחרוזות, בוליאנים, טיפוסים של Roblox כמו Vector3, CFrame, Color3 ואיברים של Enum, Instances ששני הצדדים רואים, וטבלאות מכל אלה. חלק מהערכים משתנים או נעלמים בדרך:

ארגומנטים שמגיעים לא כמו שנשלחו
אתם שולחיםמה קורה
פונקציההצד השני מקבל nil
טבלה עם מטא-טבלההמטא-טבלה הולכת לאיבוד, יחד עם כל מה שהיה לטבלה רק דרכה
טבלה שמערבבת מפתחות מספריים ומחרוזותRoblox ממליצה לא לעשות את זה: שלחו מערך נקי או מילון נקי
טבלה עם ערכי nil בתוכההימנעו: Roblox לא ממליצה על nil באף אינדקס
טבלה עם מפתחות מסוג Instance, userdata או functionמפתחות כאלה הופכים למחרוזות
Instance שהמקבל לא רואה, למשל מ-ServerStorage או כזה שנוצר ב-LocalScriptהצד השני מקבל nil
כל טבלההמקבל מקבל עותק, לא את אותה טבלה

הרגל טוב: לשלוח מזהים, לא אובייקטים או ערכים. שם של פריט, מספר אפשרות, Part שהשרת יכול למצוא ולבדוק. משם השרת עובד עם הנתונים שלו.

למה RemoteFunction מחזירה nil

אם InvokeServer מחזיר לכם nil, עברו על הסעיפים האלה לפי הסדר:

  1. מסלול בלי ערך מוחזר. כל יציאה מ-OnServerInvoke חייבת להחזיר משהו. return ריק בבדיקה מוקדמת שולח בחזרה nil.
  2. return בתוך פונקציה מקוננת. return בתוך pcall(function() ... end), בתוך handler של :Connect או בתוך task.spawn יוצא רק מהפונקציה הפנימית הזו. שמרו את התוצאה, למשל local ok, data = pcall(...), ואז החזירו את data מה-callback עצמו.
  3. ערך שלא יכול לחצות את הגבול. פונקציה או Instance שהלקוח לא רואה (למשל כל דבר ב-ServerStorage) מגיעים כ-nil. כש-instance streaming מופעל, Part שהשרת הרגע יצר עלול עוד לא להגיע ללקוח ברגע החזרה מהפונקציה.
  4. סקריפט אחר קבע את ה-callback. עובדת רק ההצבה האחרונה של OnServerInvoke. חפשו את שם ה-remote בסקריפטים שלכם.

אם הקריאה בכלל לא חוזרת, זה אומר שאף סקריפט עוד לא קבע OnServerInvoke (Roblox מחזיקה קריאות בתור עד שיקבעו אותו), או שה-callback נתקע, למשל ב-WaitForChild למשהו שלא יופיע אף פעם.

UnreliableRemoteEvent: לעדכונים חד-פעמיים תכופים

ל-UnreliableRemoteEvent יש אותן שיטות ואותם אירועים כמו ל-RemoteEvent: FireServer, FireClient, FireAllClients, OnServerEvent ו-OnClientEvent. ההבדל הוא ש-Roblox לא מבטיחה לא מסירה ולא סדר. הודעה יכולה להיזרק בלי שליחה חוזרת כש:

  • היא הולכת לאיבוד בדרך, או מחכה יותר מדי זמן ברשת עמוסה
  • הנתונים שלה גדולים מ-1000 בתים
  • הלקוח שולח מעבר למגבלה (העודף נזרק, לא נדחה)
  • ברגע ההגעה לא מחובר אף handler (היא נזרקת, לא נכנסת לתור)

הודעות יכולות גם להגיע לא לפי הסדר, והסדר שלהן לא קשור בשום אופן ל-RemoteEvents או ל-RemoteFunctions שלכם. השתמשו בו כשחשוב רק הערך העדכני ביותר, והעדכון הבא יגיע בעוד שבריר שנייה: לאן השחקן מכוון, מיקום של אפקט קוסמטי, ערך שמשתנה בכל פריים. אם הסדר חשוב, הכניסו לכל הודעה מספר סידורי או חותמת זמן, והתעלמו מכל מה שישן מהאחרון שטופל.

אף פעם אל תשתמשו בו למשהו שצריך לקרות בדיוק פעם אחת, למשל לקנייה, לנזק, לפרס או לתחילת סיבוב. ובדקו את הארגומנטים שלו בשרת בדיוק כמו של RemoteEvent.

סדר מסירה ומגבלות קצב

הבטחות המסירה של Roblox חלות על חיבור אחד בכיוון אחד: מהשרת ללקוח אחד, או מלקוח אחד לשרת.

  • RemoteEvents אמינים ומסודרים. הודעות שהלכו לאיבוד נשלחות שוב כל עוד המקבל מחובר, והודעות מגיעות לפי הסדר שבו שלחתם אותן, גם דרך RemoteEvents שונים. אם השרת שולח לשחקן A, אחר כך B, ואז A, השחקן הזה מקבל A, B, A.
  • הסדר נוגע לרגע שבו ה-handlers מופעלים. אם handler מוותר על השליטה, למשל דרך task.wait או WaitForChild, ההודעה הבאה יכולה להתחיל להיות מטופלת לפני שהראשונה מסתיימת.
  • RemoteFunctions ו-RemoteEvents לא מסודרים אלה ביחס לאלה. אם הקוד שלכם תלוי בסדר קפדני, שלחו הודעות קשורות דרך סוג אחד של remote, או הוסיפו מספר סידורי משלכם.
  • שינויים של מאפיינים ו-Attributes לא מסודרים ביחס ל-remotes. אם השרת משנה מאפיין ואז קורא ל-remote, הלקוח יכול לראות קודם כל אחד מהשניים. האזינו לשינוי עצמו, למשל דרך GetPropertyChangedSignal, ואל תניחו שהוא כבר הגיע.
  • עוד אין handler. הודעות RemoteEvent עומדות בתור עד שמתחבר handler. לתור יש גבולות: כשהוא מלא, ההודעות הבאות נזרקות, וב-Output מופיעה השגיאה Remote event invocation discarded.
  • שחקן שיוצא מאבד את כל ההודעות שעוד לא הספיקו להגיע אליו.

מגבלת קצב. הודעות RemoteEvent ו-UnreliableRemoteEvent מהלקוח לשרת מוגבלות לבערך 500 בקשות בשנייה לכל לקוח, לפי התיעוד נכון ל-30 בספטמבר 2026. המגבלה משותפת לכל ה-remotes מאותו סוג, ולכן פיצול של remote עמוס אחד לעשרה לא מעלה אותה. מעבר למגבלה, הודעות RemoteEvent מטופלות מאוחר יותר ושומרות על הסדר, והודעות UnreliableRemoteEvent נזרקות. המגבלה של המנוע לא מונעת בשום אופן משחקן אחד לקרוא ל-remote שלכם 50 פעמים בשנייה, ולכן כל handler שמשנה משהו עדיין צריך מגבלה משלו לכל שחקן.

RemoteEvent, RemoteFunction, UnreliableRemoteEvent או Attribute?

איך לבחור את דרך התקשורת בין הלקוח לשרת
השתמשו בבשביל מהדוגמהלמה לשים לב
RemoteEventהודעות לכיוון אחד שחייבות להגיע, ולפי הסדרלקוח: "תצבע את ה-Part הזה". שרת: "תציג את ההתראה הזו"בדקו כל ארגומנט בשרת
RemoteFunction עם InvokeServerהלקוח צריך תשובה לפני שהוא יכול להמשיךלהזין קוד הטבה, לאשר קנייהמי שקרא מחכה; כל מסלול חייב להחזיר ערך
RemoteFunction עם InvokeClientכמעט אף פעםהשתמשו במקום זה ב-FireClientלקוח שיש לו שגיאה, שיצא או שלא ענה, שובר או תוקע את הקריאה בשרת
UnreliableRemoteEventעדכונים תכופים שבהם חשוב רק האחרוןכיוון הכוונון, אפקטים קוסמטייםהודעות הולכות לאיבוד או משנות סדר; מגבלת נתונים של 1000 בתים
Attribute או אובייקט ערך שהשרת קבעמצב משותף שצריך להיות גלוי תמיד, כולל לשחקנים שנכנסו מאוחר יותרטיימר סיבוב, שלב המשחק, האם הדלת פתוחהלכולם מגיעים רק שינויים של השרת; לקוחות מאזינים דרך GetAttributeChangedSignal או Changed
BindableEventתקשורת בין סקריפטים באותו צדסקריפט שרת אחד מודיע לאחר שהסיבוב נגמרלא עובר בין השרת ללקוח

דוגמה מלאה לאיך RemoteFunction ובדיקות עובדות יחד במקום שבו שחקנים משלמים, ראו במדריך איך ליצור GUI של חנות. לגבי השורה על Attributes, סקריפט השרת מהמדריך לדלתות קובע את ה-Attribute בשם Open על כל דלת בכל תנועה שלה, כך שכל LocalScript יכול להגיב אליו.

שגיאות נפוצות ופתרונות

רוב הבעיות עם remotes נראות בחלון ה-Output (פתחו אותו מתפריט Window או מהלשונית Script). הסתכלו שם קודם, ואז מצאו את התסמין שלכם למטה. המדריך לשגיאות בסקריפטים מפרט יותר את הודעות השגיאה הכלליות.

Infinite yield possible ב-WaitForChild ל-remote

הסקריפט מחכה ל-remote שלא יופיע אף פעם. בדקו שהשם והאותיות הגדולות והקטנות תואמים בדיוק, ושה-remote נמצא ב-ReplicatedStorage, לא ב-ServerStorage או ב-ServerScriptService, שהלקוחות לא רואים.

השרת מקבל ערכים לא נכונים, בהזזה של אחד

ה-LocalScript העביר את השחקן עצמו, כמו ב-remote:FireServer(player, 5). Roblox ממילא מוסיפה את השולח כפרמטר הראשון, ולכן השרת רואה (player, player, 5). קראו ל-remote:FireServer(5).

שום דבר לא קורה כשאני קורא ל-remote

בדקו שכל קריאה באה מהצד הנכון: FireServer ו-InvokeServer עובדים רק מקוד לקוח, ו-FireClient, FireAllClients ו-InvokeClient רק מ-Script של שרת. LocalScript אף פעם לא רץ ב-ServerScriptService, ב-ServerStorage או ישירות ב-Workspace; שימו אותו ב-StarterPlayerScripts, ב-StarterGui, ב-StarterCharacterScripts או ב-StarterPack. אחר כך חפשו ב-Output שגיאה בתוך ה-handler.

Remote event invocation discarded

הודעות הגיעו ל-RemoteEvent שלא היה לו handler מחובר, והתור התמלא. בדרך כלל הסקריפט עם ה-handler נופל עם שגיאה לפני השורה עם :Connect, מושבת, או תקוע בהמתנה למשהו שאף פעם לא ייטען. חברו handlers קרוב לתחילת הסקריפט.

אצלי זה עובד, אבל שחקנים אחרים לא רואים את השינוי

השינוי נעשה בלקוח, ב-LocalScript או ב-handler של OnClientEvent. עשו אותו ב-handler של OnServerEvent בשרת.

InvokeServer אף פעם לא חוזר

או שאף סקריפט לא קבע את OnServerInvoke (Roblox מחזיקה קריאות בתור עד שיקבעו אותו), או שה-callback נתקע על משהו שמוותר על השליטה, למשל WaitForChild או בקשה למאגר נתונים. הוסיפו print בתחילת ה-callback ובסופו, כדי לראות איפה הוא נעצר.

לעשות עם RoCode

גם RoCode יכול להגדיר את זה, ישירות בפלייס שפתוח אצלכם. RoCode הוא סוכן AI שעובד דרך פלאגין ל-Roblox Studio, ולכן הוא יוצר remotes וסקריפטים ב-Explorer שלכם, ולא נותן קוד שצריך להדביק.

אתם כותבים

תן לשחקנים לצבוע Parts בתיקייה Paintable בלחיצה. תשתמש ב-RemoteEvent ותשאיר את הבדיקות בשרת: רק Parts מהתיקייה הזו, לא יותר מ-30 studs ולא יותר מכמה צביעות בשנייה.

RoCode עושה
  • בדרך כלל קודם סורק את הפלייס עם Search Game ו-Search Scripts, בחיפוש אחרי תיקיית Remotes או handler קיימים, ומשתמש בתיקיות שלכם אם יש
  • יוצר RemoteEvent ב-ReplicatedStorage עם Create Instance וכותב Script של שרת ו-LocalScript עם Create Script
  • לפני הסיום בודק את הקומפילציה של כל סקריפט עם Check Script בתוך Studio. זה תופס שגיאות קומפילציה, לא שגיאות לוגיקה: הוא לא בודק טיפוסים, לא מריץ linter ולא מבצע את הקוד שלכם
  • שולח את השינויים בקבוצות, וכל קבוצה היא נקודת ביטול בהיסטוריה של Studio

עם פלאגין 3.9 ומעלה RoCode יכול להריץ בדיקת משחק קצרה ולקרוא את השגיאות, ועם פלאגין 3.9.11 ומעלה יכול לשלוט בדמות בדיקה, אבל על Parts בחלון התלת-ממדי הוא לא לוחץ. לחצו על Play בעצמכם ונסו לשבור את הבדיקות, למשל לצבוע Part מהצד השני של המפה. אם הופיעה שגיאה, Check Output יכול לקרוא את שורות ה-Server וה-Client מבדיקת המשחק האחרונה שלכם. רוב מערכות המשחק מתקשרות דרך remotes כאלה, ולכן תפגשו אותם שוב כשתבנו משחק מערכת אחר מערכת עם RoCode. איך RoCode מתחבר ל-Studio.

שאלות נפוצות

מה זה securing the client-server boundary ב-Roblox?

כך נקרא עמוד התיעוד של Roblox על אבטחת remotes, והרעיון פשוט: כל מה שהלקוח שולח דרך RemoteEvent או RemoteFunction עלול לבוא מאקספלויטר, ולכן השרת בודק את זה לפני שהוא פועל. בדקו את הסוג של כל ארגומנט, שמרו מספרים בגבולות סבירים, בדקו שלשחקן מותר עכשיו לעשות את זה, והגבילו כמה פעמים כל שחקן יכול לקרוא ל-remote. רשימת הבדיקות שלמעלה מראה כל אחת מהן בקוד.

בטוח להשתמש ב-RemoteFunction?

InvokeServer בטוח בדיוק כמו ה-callback שלכם בשרת: בדקו את הארגומנטים שלו והגבילו את הקצב, כמו בכל RemoteEvent. הכיוון המסוכן הוא InvokeClient, כי לקוח שיש לו שגיאה, שיצא או שאף פעם לא החזיר ערך, שובר או תוקע את הקריאה בשרת.

אקספלויטרים יכולים לראות ולהפעיל את ה-remotes שלי?

כן. כל מה שנמצא ב-ReplicatedStorage מגיע לכל לקוח, ולקוח מתוקן יכול להפעיל כל remote עם כל ארגומנט. שינוי שם או הסתרה של remotes לא הופכים אותם לבטוחים; מה שהופך אותם לבטוחים הוא בדיקה של כל ארגומנט בשרת.

לקוח אחד יכול לשלוח RemoteEvent ללקוח אחר?

ישירות לא. שלחו אותו לשרת, בדקו שם, ואז השתמשו ב-FireClient או ב-FireAllClients.

כמה פעמים אפשר להפעיל RemoteEvent?

בתיעוד של Roblox מצוינת מגבלה של בערך 500 בקשות בשנייה לכל לקוח להודעות RemoteEvent ו-UnreliableRemoteEvent שנשלחות לשרת, משותפת לכל ה-remotes מאותו סוג. הישארו הרבה מתחתיה, ותנו לכל handler מגבלה משלו לכל שחקן.

FireAllClients מגיע לשחקנים שנכנסו מאוחר יותר?

לא. הוא מגיע לשחקנים שמחוברים באותו רגע. למצב שמאחרים צריכים, קבעו בשרת Attribute או אובייקט ערך.

מה ההבדל בין RemoteEvent ל-BindableEvent?

RemoteEvent עובר בין השרת ללקוח. BindableEvent מחבר סקריפטים באותו צד, למשל שני סקריפטים של שרת.

מקורות וקריאה נוספת

איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.

נסו את RoCode במשחק שלכם.

קרדיטים חינמיים בכל יום, בלי כרטיס אשראי. התקינו את הפלאגין, תארו פיצ'ר ובדקו מה מופיע ב-Studio.