בקצרה
RemoteEvent הוא אובייקט שבדרך כלל נמצא ב-ReplicatedStorage ומעביר הודעות דרך הגבול בין הלקוח לשרת. LocalScript קורא ל-FireServer, והשרת מקבל את ההודעה ב-OnServerEvent, שבו נוסף כארגומנט ראשון ה-Player ששלח אותה. השרת קורא ל-FireClient(player, ...) או ל-FireAllClients(...), ו-LocalScripts מקבלים את ההודעה ב-OnClientEvent.
- השתמשו ב-RemoteFunction (
InvokeServerו-OnServerInvoke) רק כשהלקוח צריך תשובה. הימנעו מ-InvokeClient: לקוח שקרתה אצלו שגיאה, שיצא או שאף פעם לא החזיר ערך, שובר את הקריאה בשרת. - אף פעם אל תסמכו על מה שהלקוח שולח. בשרת בדקו את הסוג, הטווח והבעלות של כל ארגומנט, את המרחק לשחקן, וכמה פעמים הוא קורא ל-remote.
- פונקציות, מטא-טבלאות ואובייקטים שהצד השני לא רואה לא שורדים את ההעברה. UnreliableRemoteEvent יכול לאבד הודעות או לשנות את הסדר שלהן, וזורק כל נתון שגדול מ-1000 בתים.
בעמוד הזה
למה צריך RemoteEvents
כל משחק Roblox עובד כשרת אחד ועוד לקוח אחד לכל שחקן. השרת כאן הבוס: אובייקט חדש או שינוי מאפיין מגיעים לכל השחקנים רק כשהשרת עושה אותם. שינוי שנעשה ב-LocalScript נשאר במכשיר אחד, חוץ מכמה חריגים כמו הדמות של השחקן עצמו, שהלקוח שלו שולט בתנועה שלה. לכן כשלחיצה או מקש צריכים לשנות את העולם המשותף, הלקוח צריך לבקש מהשרת, וכשהשרת רוצה שהמסך של שחקן אחד יגיב, הוא צריך להודיע על זה ללקוח. אם ההפרדה בין Script ל-LocalScript חדשה לכם, קראו קודם את Script vs LocalScript vs ModuleScript (באנגלית). אם הסקריפטים עצמם חדשים לכם, התחילו מאיך כותבים סקריפטים ב-Roblox Studio.
כדי לחצות את הגבול הזה Roblox נותנת שלושה אובייקטים:
- RemoteEvent: הודעה לכיוון אחד. השולח ממשיך מיד בעבודה.
- RemoteFunction: בקשה שמחכה לתשובה. הקוד שקרא עומד בהשהיה עד שהצד השני מחזיר ערך.
- UnreliableRemoteEvent: הודעה לכיוון אחד שעלולה ללכת לאיבוד או להגיע לא לפי הסדר, אבל מעמיסה פחות על הרשת. מתאים לנתונים שמשתנים כל הזמן.
| כיוון | השולח קורא ל | המקבל מתחבר ל | המקבל מקבל |
|---|---|---|---|
| מהלקוח לשרת | remote:FireServer(...) ב-LocalScript | remote.OnServerEvent ב-Script | ה-Player ששלח את ההודעה, ואחריו הארגומנטים שלכם |
| מהשרת ללקוח אחד | remote:FireClient(player, ...) ב-Script | remote.OnClientEvent ב-LocalScript | רק הארגומנטים שלכם |
| מהשרת לכל הלקוחות | remote:FireAllClients(...) ב-Script | remote.OnClientEvent ב-LocalScript | רק הארגומנטים שלכם |
| הלקוח שואל, השרת עונה | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player, ואחריו הארגומנטים שלכם. מי שקרא מקבל את מה שהפונקציה החזירה |
לקוחות לא יכולים לשלוח הודעות זה לזה ישירות. כדי להעביר משהו משחקן אחד לשאר, שלחו אותו לשרת, בדקו שם, ותנו לשרת להעביר הלאה דרך FireClient או FireAllClients. לפי המלצות האבטחה של Roblox, השרת כאן עובד כשומר סף, לא כממסר פשוט.
איפה שומרים remotes
remote צריך להיות במקום שבו גם השרת וגם הלקוחות רואים אותו. המקום הרגיל הוא ReplicatedStorage; בתיעוד של Roblox מצוין שבחלק מהמקרים מתאימים גם Workspace או Tool. ServerStorage ו-ServerScriptService זמינים רק לשרת, ולכן LocalScript שמחכה ל-remote משם יחכה לנצח.
- ב-Explorer רחפו מעל ReplicatedStorage, לחצו על כפתור ה-+ והכניסו Folder. קראו לתיקייה
Remotes. - רחפו מעל
Remotes, לחצו על + והכניסו RemoteEvent. שנו את השם שלו כך שיתאר את המטרה, למשלPaintRequest. - חזרו על זה לכל remote. במדריך הזה משתמשים בשני RemoteEvents (
PaintRequestו-Notify) וב-RemoteFunction אחת (RedeemCode).
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 ואת המספר של הצבע. את הצבע עצמו הוא אף פעם לא שולח, ובמשחקים אחרים הוא באותה מידה לא אמור לשלוח מחיר, פרס או גודל נזק. לקוח מתוקן יכול לשלוח כל דבר, ולכן את הנתונים האמיתיים (כאן זו הפלטה) שומר השרת, ואת הארגומנטים הוא רואה כבקשה שצריך לבדוק.
- ב-Workspace הכניסו Folder בשם
Paintableושימו בו כמה Parts מעוגנים. - בדקו שב-
ReplicatedStorage.Remotesיש RemoteEvent בשםPaintRequest. - הכניסו Script בשם
PaintServerל-ServerScriptService ו-LocalScript בשםPaintClientל-StarterPlayer, StarterPlayerScripts, עם הקוד שלמטה.
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. אין סיבה להסביר ללקוח רמאי למה סירבו לו.
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.
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
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.
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, כי הוא לא מחכה.
דוגמה: שדה שבו שחקנים מקלידים קוד הטבה. השרת שומר את הקודים, בודק את הטקסט ומחזיר שני ערכים: האם זה עבד, והודעה שצריך להציג.
- ב-
ReplicatedStorage.Remotesהכניסו RemoteFunction בשםRedeemCode. - ב-StarterGui הכניסו ScreenGui בשם
CodeGui, ובתוכו TextBox בשםCodeBox. את הגודל והמקום בחרו לפי הטעם. - הוסיפו את ה-Script שלמטה ל-ServerScriptService, ואת ה-LocalScript לתוך
CodeBox.
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 מהמדריך לטבלת מובילים. קודים שנוצלו נזכרים רק עד שהשחקן יוצא, ולכן בצורה הזו שחקן יכול להיכנס מחדש ולהזין את אותו קוד שוב. אם המטבעות נשמרים, אלה מטבעות חינם בכל כניסה מחדש: לפני שמשתמשים בזה במשחק חי, שמרו את הקודים שכל שחקן ניצל יחד עם הנתונים השמורים שלו במאגר נתונים.
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.
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:
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, עברו על הסעיפים האלה לפי הסדר:
- מסלול בלי ערך מוחזר. כל יציאה מ-
OnServerInvokeחייבת להחזיר משהו.returnריק בבדיקה מוקדמת שולח בחזרהnil. - return בתוך פונקציה מקוננת.
returnבתוךpcall(function() ... end), בתוך handler של:Connectאו בתוךtask.spawnיוצא רק מהפונקציה הפנימית הזו. שמרו את התוצאה, למשלlocal ok, data = pcall(...), ואז החזירו אתdataמה-callback עצמו. - ערך שלא יכול לחצות את הגבול. פונקציה או Instance שהלקוח לא רואה (למשל כל דבר ב-ServerStorage) מגיעים כ-
nil. כש-instance streaming מופעל, Part שהשרת הרגע יצר עלול עוד לא להגיע ללקוח ברגע החזרה מהפונקציה. - סקריפט אחר קבע את ה-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 ולא יותר מכמה צביעות בשנייה.
- בדרך כלל קודם סורק את הפלייס עם 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 מחבר סקריפטים באותו צד, למשל שני סקריפטים של שרת.
מקורות וקריאה נוספת
- Roblox Creator Docs: Remote events and callbacks (באנגלית). FireServer, FireClient, InvokeServer, הסיכונים של InvokeClient, הגבלות על ארגומנטים והבטחות מסירה
- Roblox Creator Docs: Securing the client-server boundary (באנגלית). שכבות בדיקה, NaN, מגבלות קצב, העברה מלקוח ללקוח
- Roblox Creator Docs: Security and cheat mitigation tactics (באנגלית). מה לקוח מתוקן יכול לעשות, והסמכות של השרת
- Roblox Creator Docs: Network ownership, movement validation, and physics (באנגלית). למה הלקוח שולט בדמות שלו, והגבולות של בדיקות מרחק
- Roblox Engine API: RemoteEvent (באנגלית). מגבלת הקצב והשגיאה invocation discarded
- Roblox Engine API: RemoteFunction (באנגלית). OnServerInvoke, האזהרות על InvokeClient ואמצעי זהירות עם streaming
- Roblox Engine API: UnreliableRemoteEvent (באנגלית). מגבלת נתונים של 1000 בתים
- Roblox Creator Docs: Properties and attributes (באנגלית). סדר השכפול בין שינויים של מאפיינים ל-remote events
איך הקוד נבדק: כל סקריפט בעמוד הזה עובר את בודק הטיפוסים המחמיר של Luau עם הגדרות ה-API של Roblox (luau-lsp, 20 בנובמבר 2026). בדיקת טיפוסים תופסת שגיאות בשמות API וטיפוסים שגויים, אבל לא שגיאות בלוגיקת המשחק, אז בדקו הכול ב-Studio לפני הפרסום.