संक्षेप में
RemoteEvent एक ऑब्जेक्ट है जो आमतौर पर ReplicatedStorage में रहता है और क्लाइंट और सर्वर की सीमा के पार संदेश पहुँचाता है। LocalScript FireServer कॉल करता है, और सर्वर को संदेश OnServerEvent में मिलता है, जहाँ पहले argument के रूप में भेजने वाला Player जुड़ा होता है। सर्वर FireClient(player, ...) या FireAllClients(...) कॉल करता है, और LocalScript को संदेश OnClientEvent में मिलता है।
- RemoteFunction (
InvokeServerऔरOnServerInvoke) तभी इस्तेमाल करें जब क्लाइंट को जवाब चाहिए।InvokeClientसे बचें: जिस क्लाइंट में एरर आए, जो चला जाए या कभी वैल्यू न लौटाए, वह सर्वर पर कॉल तोड़ देता है। - क्लाइंट जो भेजता है उस पर कभी भरोसा न करें। सर्वर पर हर argument का टाइप, रेंज और ओनरशिप, प्लेयर की दूरी, और वह remote कितनी बार कॉल करता है, यह सब जाँचें।
- फ़ंक्शन, metatables और वे ऑब्जेक्ट जो दूसरी तरफ़ नहीं दिखते, भेजे जाने के बाद नहीं बचते। UnreliableRemoteEvent संदेश खो सकता है या उनका क्रम बदल सकता है, और 1000 बाइट से बड़ा कोई भी डेटा छोड़ देता है।
इस पेज पर
RemoteEvent क्यों चाहिए
हर Roblox गेम एक सर्वर और हर प्लेयर के लिए एक क्लाइंट की तरह चलता है। यहाँ सर्वर मुख्य है: कोई नया ऑब्जेक्ट या प्रॉपर्टी का बदलाव सब प्लेयर्स तक तभी पहुँचता है जब उसे सर्वर करे। LocalScript में किया बदलाव एक डिवाइस पर रहता है, कुछ अपवादों को छोड़कर, जैसे प्लेयर का अपना कैरेक्टर, जिसकी हरकत उसका क्लाइंट कंट्रोल करता है। इसलिए जब किसी क्लिक या बटन से साझा दुनिया बदलनी हो, तो क्लाइंट को सर्वर से कहना होता है, और जब सर्वर चाहता है कि एक प्लेयर की स्क्रीन प्रतिक्रिया दे, तो उसे क्लाइंट को बताना होता है। अगर Script और LocalScript का बँटवारा आपके लिए नया है, तो पहले Script vs LocalScript vs ModuleScript (अंग्रेज़ी में) पढ़ें। अगर स्क्रिप्टिंग ही नई है, तो यहाँ से शुरू करें कि Roblox Studio में स्क्रिप्ट कैसे लिखें।
इस सीमा को पार करने के लिए Roblox तीन ऑब्जेक्ट देता है:
- RemoteEvent: एक तरफ़ का संदेश। भेजने वाला तुरंत आगे काम करता है।
- RemoteFunction: एक अनुरोध जो जवाब का इंतज़ार करता है। कॉल करने वाला कोड तब तक रुका रहता है जब तक दूसरी तरफ़ वैल्यू न लौटाए।
- UnreliableRemoteEvent: एक तरफ़ का संदेश जो खो सकता है या क्रम से बाहर आ सकता है, पर नेटवर्क पर कम बोझ डालता है। लगातार बदलने वाले डेटा के लिए ठीक है।
| दिशा | भेजने वाला कॉल करता है | पाने वाला इससे जुड़ता है | पाने वाले को मिलता है |
|---|---|---|---|
| क्लाइंट से सर्वर | LocalScript में remote:FireServer(...) | Script में remote.OnServerEvent | संदेश भेजने वाला Player, फिर आपके arguments |
| सर्वर से एक क्लाइंट | Script में remote:FireClient(player, ...) | LocalScript में remote.OnClientEvent | सिर्फ़ आपके arguments |
| सर्वर से सब क्लाइंट | Script में remote:FireAllClients(...) | LocalScript में remote.OnClientEvent | सिर्फ़ आपके arguments |
| क्लाइंट पूछता है, सर्वर जवाब देता है | remoteFunction:InvokeServer(...) | remoteFunction.OnServerInvoke = function(player, ...) | Player, फिर आपके arguments। कॉल करने वाले को वह मिलता है जो फ़ंक्शन ने लौटाया |
क्लाइंट सीधे एक-दूसरे को संदेश नहीं भेज सकते। एक प्लेयर से बाक़ी को कुछ भेजने के लिए उसे सर्वर पर भेजें, वहाँ जाँचें, और सर्वर उसे FireClient या FireAllClients से आगे भेजे। Roblox की सुरक्षा सलाह के अनुसार यहाँ सर्वर दरबान की तरह काम करता है, सिर्फ़ आगे बढ़ाने वाले की तरह नहीं।
Remotes कहाँ रखें
Remote वहाँ होना चाहिए जहाँ सर्वर और क्लाइंट दोनों उसे देख सकें। आम जगह ReplicatedStorage है; Roblox डॉक्यूमेंटेशन बताता है कि कुछ मामलों में Workspace या Tool भी चलते हैं। ServerStorage और ServerScriptService सिर्फ़ सर्वर के लिए हैं, इसलिए वहाँ से remote का इंतज़ार करने वाला LocalScript हमेशा इंतज़ार करता रहेगा।
- Explorer में ReplicatedStorage पर कर्सर ले जाएँ, + बटन दबाएँ और एक Folder डालें। फ़ोल्डर का नाम
Remotesरखें। Remotesपर कर्सर ले जाएँ, + दबाएँ और एक RemoteEvent डालें। उसका नाम ऐसा रखें जो उसका काम बताए, जैसेPaintRequest।- हर remote के लिए दोहराएँ। इस गाइड में दो RemoteEvent (
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 रखें: तब हर सर्वर हैंडलर arguments का एक ही रूप जाँचता है, और सब कामों के लिए एक remote की तुलना में यह सही करना बहुत आसान है।
पैटर्न 1: क्लाइंट से सर्वर, सर्वर पर जाँच के साथ
सबसे आम काम: प्लेयर अपनी स्क्रीन पर कुछ करता है, और सर्वर तय करता है कि क्या होगा। यहाँ प्लेयर चार रंगों में से एक चुनने के लिए Q दबाता है और किसी पार्ट को रंगने के लिए उस पर क्लिक या टैप करता है। नया रंग सब देखते हैं, क्योंकि रंगने का काम सर्वर करता है।
क्लाइंट दो चीज़ें भेजता है: कौन सा पार्ट और रंग का नंबर। रंग ख़ुद वह कभी नहीं भेजता, और दूसरे गेम्स में भी उसे इसी तरह कीमत, इनाम या डैमेज की मात्रा नहीं भेजनी चाहिए। बदला हुआ क्लाइंट कुछ भी भेज सकता है, इसलिए असली डेटा (यहाँ रंगों की palette) सर्वर रखता है, और arguments को वह एक अनुरोध मानता है जिसे जाँचना है।
- Workspace में
Paintableनाम का Folder डालें और उसमें कुछ anchored Part रखें। - जाँचें कि
ReplicatedStorage.RemotesमेंPaintRequestनाम का RemoteEvent है। - ServerScriptService में
PaintServerनाम की Script और StarterPlayer, StarterPlayerScripts मेंPaintClientनाम की LocalScript डालें, नीचे के कोड के साथ।
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
local COOLDOWN_SECONDS = 0.25
local lastPaint: { [Player]: number } = {}
-- पहला parameter हमेशा वह प्लेयर है जिसने remote कॉल किया। इसे Roblox डालता है,
-- इसलिए इस पर भरोसा किया जा सकता है। इसके बाद का सब क्लाइंट से आया है, और उस पर भरोसा नहीं किया जा सकता।
paintRequest.OnServerEvent:Connect(function(player: Player, part: unknown, colourIndex: unknown)
-- 1. टाइप: असली पार्ट, न कि उसका दिखावा करने वाली टेबल
if typeof(part) ~= "Instance" or not part:IsA("BasePart") then
return
end
-- 2. रेंज: 1 से 4 तक का पूर्णांक। NaN और अनंत भी यहीं छँट जाते हैं।
if type(colourIndex) ~= "number" or not math.isfinite(colourIndex) then
return
end
if colourIndex % 1 ~= 0 or colourIndex < 1 or colourIndex > #PALETTE then
return
end
-- 3. अनुमत लक्ष्य: सिर्फ़ Paintable फ़ोल्डर के पार्ट्स, गेम में और कुछ नहीं
if not part:IsDescendantOf(paintable) then
return
end
-- 4. दूरी: प्लेयर का कैरेक्टर पार्ट के पास होना चाहिए
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not (root and root:IsA("BasePart")) then
return
end
if (root.Position - part.Position).Magnitude > MAX_DISTANCE then
return
end
-- 5. दर की सीमा: हर प्लेयर पर चौथाई सेकंड में एक रंगाई
local now = os.clock()
local last = lastPaint[player]
if last and now - last < COOLDOWN_SECONDS then
return
end
lastPaint[player] = now
part.Color = PALETTE[colourIndex]
end)
Players.PlayerRemoving:Connect(function(player: Player)
lastPaint[player] = nil
end)
हर फ़ेल हुई जाँच बस return करती है। चीटर क्लाइंट को यह समझाने की कोई ज़रूरत नहीं कि उसे मना क्यों किया गया।
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")
local remotes = ReplicatedStorage:WaitForChild("Remotes")
local paintRequest = remotes:WaitForChild("PaintRequest") :: RemoteEvent
local paintable = workspace:WaitForChild("Paintable")
local COLOUR_COUNT = 4 -- असली रंग सर्वर रखता है
local selectedColour = 1
-- किरण सिर्फ़ Paintable फ़ोल्डर के अंदर के पार्ट्स से टकरा सकती है
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Include
rayParams.FilterDescendantsInstances = { paintable }
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessed: boolean)
if gameProcessed then
return -- बटन या क्लिक चैट या किसी बटन में गया
end
if input.KeyCode == Enum.KeyCode.Q then
selectedColour = selectedColour % COLOUR_COUNT + 1
return
end
local isClick = input.UserInputType == Enum.UserInputType.MouseButton1
local isTap = input.UserInputType == Enum.UserInputType.Touch
if isClick or isTap then
local camera = workspace.CurrentCamera
local ray = camera:ScreenPointToRay(input.Position.X, input.Position.Y)
local result = workspace:Raycast(ray.Origin, ray.Direction * 500, rayParams)
if result then
-- माँगते हैं, हुक्म नहीं देते: रंगना है या नहीं, सर्वर तय करता है
paintRequest:FireServer(result.Instance, selectedColour)
end
end
end)
gameProcessed तब true होता है जब इंजन यह इनपुट पहले ही संभाल चुका है, आमतौर पर UI में: बटन पर क्लिक, या चैट लाइन जैसे टेक्स्ट बॉक्स में टाइप किए अक्षर। इस जाँच की वजह से संदेश में टाइप किया Q रंग नहीं बदलता।
पैटर्न 2: सर्वर से एक क्लाइंट
सर्वर एक प्लेयर को FireClient से संदेश भेजता है। पहला argument वह Player है जिसके लिए संदेश है, और क्लाइंट का हैंडलर सिर्फ़ उसके बाद के arguments पाता है। इसे हर निजी चीज़ के लिए इस्तेमाल करें: नोटिफ़िकेशन, इनाम वाली विंडो, ऐसी आवाज़ जो सिर्फ़ उसी प्लेयर को सुनाई दे। कटसीन गाइड इसका बड़ा, समझाया हुआ उदाहरण है: सर्वर तय करता है कि प्लेयर कटसीन कब देखेगा, और उसके फ़्रेम उसी एक प्लेयर को 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)
-- पहला argument चुनता है कि कौन सा क्लाइंट संदेश पाएगा। और कोई उसे नहीं देखेगा।
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 parameter नहीं है: सर्वर पहले ही चुन चुका है कि संदेश किसे मिलेगा
notify.OnClientEvent:Connect(function(message: string)
messageCount += 1
local thisMessage = messageCount
label.Text = message
label.Visible = true
task.delay(4, function()
if messageCount == thisMessage then -- छिपाते हैं, अगर इसे किसी नए संदेश ने नहीं बदला
label.Visible = false
end
end)
end)
सर्वर PlayerAdded पर संदेश भेजता है, और यह इस LocalScript के अपना हैंडलर जोड़ने से पहले हो सकता है। यह ठीक है: Roblox हैंडलर के आने से पहले पहुँचे RemoteEvent संदेशों को कतार में रखता है और हैंडलर जुड़ते ही उन्हें क्रम से पहुँचा देता है।
क्लाइंट को सर्वर से बचने की ज़रूरत नहीं: OnClientEvent सिर्फ़ सर्वर का कोड चला सकता है। message: string एनोटेशन टाइप जाँच के लिए है; यह रनटाइम पर जाँच नहीं है।
पैटर्न 3: सर्वर से सब क्लाइंट
FireAllClients हर जुड़े हुए प्लेयर को एक ही संदेश भेजता है। इसमें Player argument नहीं होता, और हर क्लाइंट को संदेश पहले वाले उसी OnClientEvent में मिलता है, इसलिए पैटर्न 2 की NotifyClient स्क्रिप्ट उसे पहले से दिखाती है।
यह Script सबको बताती है जब कोई प्लेयर पहली बार फ़िनिश लाइन छूता है। Workspace में FinishLine नाम का anchored Part जोड़ें, फिर ServerScriptService में Script जोड़ें।
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local notify = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("Notify") :: RemoteEvent
local finishLine = workspace:WaitForChild("FinishLine") :: BasePart
local finished: { [Player]: boolean } = {}
finishLine.Touched:Connect(function(hit: BasePart)
local character = hit:FindFirstAncestorOfClass("Model")
local player = character and Players:GetPlayerFromCharacter(character)
if not player or finished[player] then
return -- प्लेयर नहीं है या पहले ही घोषित हो चुका
end
finished[player] = true
-- हर जुड़ा क्लाइंट इस टेक्स्ट के साथ अपना OnClientEvent हैंडलर चलाता है
notify:FireAllClients(`{player.DisplayName} reached the finish!`)
end)
Players.PlayerRemoving:Connect(function(player: Player)
finished[player] = nil
end)
Exploiter अपने कैरेक्टर के लिए किसी भी दूरी से Touched चला सकता है, पर हर प्लेयर पर एक बार दिखने वाली घोषणा के लिए यह नुक़सानदेह नहीं। अगर बाद में आप फ़िनिश पर इनाम देंगे, तो देने से पहले सर्वर जाँचें जोड़ें, जैसे राउंड शुरू होने से न्यूनतम समय।
FireAllClients सिर्फ़ उस पल जुड़े प्लेयर्स तक पहुँचता है। जो एक सेकंड बाद आए, उसे संदेश नहीं दिखेगा। यह एक बार के पलों के लिए ठीक है, जैसे घोषणा, धमाके का इफ़ेक्ट या आवाज़, पर राउंड टाइमर या गेम के मौजूदा चरण जैसी स्टेट के लिए नहीं। स्टेट के लिए सर्वर पर attribute सेट करें, जैसे ReplicatedStorage:SetAttribute("TimeLeft", 30), और क्लाइंट पर उसे GetAttribute और GetAttributeChangedSignal("TimeLeft") से पढ़ें। Attributes हर क्लाइंट तक replicate होते हैं, बाद में आए प्लेयर्स समेत।
RemoteFunction: जब क्लाइंट को जवाब चाहिए
RemoteEvent "भेजो और भूल जाओ" के सिद्धांत पर चलता है। RemoteFunction कॉल करने वाले को इंतज़ार करवाता है: InvokeServer उसे कॉल करने वाले कोड को तब तक रोकता है जब तक सर्वर का OnServerInvoke फ़ंक्शन वैल्यू न लौटाए, और फिर वही लौटाता है। इसे तब इस्तेमाल करें जब क्लाइंट जवाब के बिना आगे नहीं बढ़ सकता, जैसे "क्या यह कोड सही था?"। जब जवाब की ज़रूरत न हो, तो Roblox RemoteEvent सुझाता है, क्योंकि वह इंतज़ार नहीं करता।
उदाहरण: एक बॉक्स जिसमें प्लेयर्स प्रोमो कोड डालते हैं। सर्वर कोड रखता है, टेक्स्ट जाँचता है और दो वैल्यू लौटाता है: काम किया या नहीं, और दिखाने वाला संदेश।
ReplicatedStorage.RemotesमेंRedeemCodeनाम का RemoteFunction डालें।- StarterGui में
CodeGuiनाम का ScreenGui डालें, और उसके अंदरCodeBoxनाम का TextBox। साइज़ और जगह अपनी पसंद से चुनें। - नीचे की 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 } = {}
-- = से assign करते हैं। 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 stat में जोड़ता है। इस्तेमाल हुए कोड सिर्फ़ प्लेयर के जाने तक याद रहते हैं, इसलिए इस रूप में प्लेयर फिर से जुड़कर वही कोड दोबारा डाल सकता है। अगर सिक्के सेव होते हैं, तो यह हर बार फिर से जुड़ने पर मुफ़्त सिक्के हैं: लाइव गेम में इस्तेमाल करने से पहले हर प्लेयर के इस्तेमाल हुए कोड उसके सेव डेटा के साथ DataStore में रखें।
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 होता है। अगर दो स्क्रिप्ट एक ही RemoteFunction पर OnServerInvoke सेट करती हैं, तो सिर्फ़ आख़िरी काम करती है।
InvokeClient ख़तरनाक क्यों है
RemoteFunction उल्टी दिशा में भी काम करता है, सर्वर पर InvokeClient और क्लाइंट पर OnClientInvoke के साथ। Roblox डॉक्यूमेंटेशन तीन गंभीर जोखिम गिनाता है:
- अगर क्लाइंट का callback एरर देता है, तो सर्वर भी एरर देता है।
- अगर प्लेयर कॉल के दौरान चला जाता है, तो
InvokeClientएरर देता है। - अगर क्लाइंट कभी वैल्यू नहीं लौटाता, तो सर्वर स्क्रिप्ट हमेशा इंतज़ार करती रहेगी।
बदला हुआ क्लाइंट अपना callback कंट्रोल करता है, इसलिए चीटर जानबूझकर तीसरा मामला बना सकता है और उस सर्वर थ्रेड को जितना चाहे रोक सकता है। प्लेयर की स्क्रीन अपडेट करने के लिए FireClient इस्तेमाल करें। अगर सर्वर को सच में क्लाइंट से जानकारी चाहिए, तो RemoteEvent भेजें, क्लाइंट दूसरे RemoteEvent से जवाब दे, और सर्वर पर जवाब न आने को सामान्य मामला मानें।
सर्वर पर हर argument जाँचें
Exploiter कोई भी RemoteEvent या RemoteFunction जितनी बार चाहे और किसी भी arguments के साथ कॉल कर सकता है। सिर्फ़ एक चीज़ वह नक़ली नहीं बना सकता, पहला parameter: संदेश भेजने वाला Player Roblox ख़ुद डालता है। उसके बाद आने वाली हर चीज़ सर्वर के कुछ करने से पहले जाँचनी होगी। Remote छिपाना या LocalScript में जाँचना बेकार है, क्योंकि चीटर अपना क्लाइंट कंट्रोल करता है।
| जाँच | सर्वर क्या पूछता है | उदाहरण |
|---|---|---|
| टाइप | क्या यह वही टाइप है जिसकी मुझे उम्मीद है? Instance, न कि उसके जैसी दिखने के लिए बनाई गई टेबल? | typeof(part) == "Instance" and part:IsA("BasePart") |
| रेंज | क्या संख्या सीमित है और मान्य सीमाओं में है? क्या टेक्स्ट की लंबाई ठीक है? | math.isfinite(n), n >= 1 and n <= 4, #text <= 20 |
| ओनरशिप | क्या यह प्लेयर आइटम का मालिक है, उसके पास काफ़ी पैसे हैं, उसे इस ऑब्जेक्ट के साथ कुछ करने का अधिकार है? | आइटम उसकी इन्वेंटरी में है; पार्ट Paintable के अंदर है |
| दूरी | क्या दुनिया की सर्वर कॉपी में प्लेयर का कैरेक्टर काफ़ी पास है? lag के लिए थोड़ा मार्जिन छोड़ें। | पार्ट से 30 studs से ज़्यादा दूर नहीं |
| दर | क्या यह प्लेयर बहुत बार तो नहीं भेज रहा? | हर प्लेयर पर cooldown या जमा होने वाली कॉल्स की सीमा |
NaN के लिए अलग चेतावनी ज़रूरी है। यह एक संख्या है, इसलिए type(x) == "number" पास हो जाता है, पर इसके साथ हर तुलना false देती है, और x < 0 or x > 100 जैसी जाँच इसे आर-पार जाने देती है। math.isfinite(x) NaN और दोनों अनंत को रिजेक्ट करता है।
दूरी वाली जाँच की सीमा याद रखें। हर क्लाइंट अपने कैरेक्टर की फ़िज़िक्स कंट्रोल करता है, इसलिए exploiter कॉल से पहले कैरेक्टर को लक्ष्य तक ले जा सकता है। फिर भी यह जाँच सबसे आसान ग़लत इस्तेमाल रोकती है, जब एक जगह से पूरे मैप पर असर डाला जाए। लक्ष्य वाले पार्ट्स anchored रखें: Roblox का सुरक्षा डॉक्यूमेंटेशन बताता है कि exploiter अपने पास के बिना anchor वाले पार्ट्स की नेटवर्क ओनरशिप लेकर उन्हें पास खींच सकता है, और इससे दूरी वाली जाँच बायपास हो जाती है।
यहाँ वही जाँचें एक ModuleScript के रूप में हैं, जिसे हर 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 के बीच का पूर्णांक, मात्राओं, indexes और काउंटर के लिए
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 अमान्य UTF-8 के लिए nil लौटाता है, जिसे
-- DataStore रिजेक्ट करते हैं।
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
-- आपके अनुमत कंटेनर के अंदर अपेक्षित class का 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, जब प्लेयर का कैरेक्टर position से maxDistance studs से ज़्यादा दूर नहीं
function RemoteGuard.isNear(player: Player, position: Vector3, maxDistance: number): boolean
local character = player.Character
local root = character and character:FindFirstChild("HumanoidRootPart")
if not (root and root:IsA("BasePart")) then
return false
end
return (root.Position - position).Magnitude <= maxDistance
end
-- हर प्लेयर पर दर की सीमा। हर प्लेयर एक साथ `burst` कॉल कर सकता है और
-- हर सेकंड `perSecond` कॉल वापस पाता है। एक फ़ंक्शन लौटाता है, जिसे काम से पहले
-- कॉल करते हैं: वह true (ठीक है) या false (बहुत बार) जवाब देता है।
function RemoteGuard.limiter(burst: number, perSecond: number): (Player) -> boolean
local buckets: { [Player]: { tokens: number, updated: number } } = {}
Players.PlayerRemoving:Connect(function(player: Player)
buckets[player] = nil
end)
return function(player: Player): boolean
local now = os.clock()
local bucket = buckets[player]
if not bucket then
bucket = { tokens = burst, updated = now }
buckets[player] = bucket
end
bucket.tokens = math.min(burst, bucket.tokens + (now - bucket.updated) * perSecond)
bucket.updated = now
if bucket.tokens < 1 then
return false
end
bucket.tokens -= 1
return true
end
end
return RemoteGuard
इसे ServerScriptService में रखें। वहाँ का कोड कभी क्लाइंट तक नहीं पहुँचता, इसलिए आपकी जाँचें कोई नहीं पढ़ेगा।
और यह पैटर्न 1 का हैंडलर है, इसकी मदद से फिर से लिखा गया। PaintServer का कंटेंट बदल दें:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
-- ":: any" सिर्फ़ Luau की strict type checking के लिए ज़रूरी है; रनटाइम पर यह कुछ नहीं बदलता
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)
प्लेयर के जाने पर limiter उसकी एंट्री हटा देता है, इसलिए उसकी टेबल सर्वर की पूरी ज़िंदगी में बढ़ती नहीं रहती।
हथियारों में ये जाँचें सबसे ज़्यादा मायने रखती हैं: क्लाइंट को कभी यह बताने न दें कि किसे लगा। तलवार गाइड का remote कोई argument ही नहीं ले जाता, और सर्वर लक्ष्य ख़ुद ढूँढता है। गन गाइड सिर्फ़ निशाने का पॉइंट भेजती है, जिसे सर्वर अपनी किरण चलाने से पहले टाइप, NaN और दूरी के लिए जाँचता है।
मेन्यू पर भी यही नियम लागू है: चुनाव भेजें, नतीजा नहीं। NPC डायलॉग गाइड में क्लाइंट सिर्फ़ दबाए गए बटन का नंबर भेजता है, और सर्वर ख़ुद देखता है कि वह जवाब क्या देता है। टेलीपोर्ट गाइड का मेन्यू पॉइंट का नाम भेजता है, पोज़िशन नहीं, और सर्वर अपने फ़ोल्डर में पॉइंट ढूँढता है और जाँचता है कि उसके लिए कितनी Wins चाहिए।
क्या भेजा जा सकता है और क्या नहीं
संख्याएँ, स्ट्रिंग, boolean, Roblox के टाइप जैसे Vector3, CFrame, Color3 और Enum आइटम, दोनों तरफ़ दिखने वाले Instance, और इन सबसे बनी टेबल भेजी जा सकती हैं। कुछ वैल्यू रास्ते में बदल जाती हैं या ग़ायब हो जाती हैं:
| आप भेजते हैं | क्या होता है |
|---|---|
| फ़ंक्शन | दूसरी तरफ़ को nil मिलता है |
| Metatable वाली टेबल | Metatable खो जाती है, और साथ में वह सब जो टेबल के पास सिर्फ़ उसके ज़रिए था |
| ऐसी टेबल जिसमें नंबर और स्ट्रिंग keys मिली हों | Roblox ऐसा न करने की सलाह देता है: साफ़ array या साफ़ dictionary भेजें |
अंदर nil वैल्यू वाली टेबल | बचें: Roblox किसी भी index पर nil की सलाह नहीं देता |
| Instance, userdata या function टाइप की keys वाली टेबल | ऐसी keys स्ट्रिंग में बदल जाती हैं |
| ऐसा Instance जो पाने वाले को नहीं दिखता, जैसे ServerStorage से या LocalScript में बनाया हुआ | दूसरी तरफ़ को nil मिलता है |
| कोई भी टेबल | पाने वाले को एक कॉपी मिलती है, वही टेबल नहीं |
एक अच्छी आदत: ऑब्जेक्ट या वैल्यू नहीं, पहचान भेजें। आइटम का नाम, विकल्प का नंबर, एक पार्ट जिसे सर्वर ढूँढ और जाँच सके। आगे सर्वर अपने डेटा के साथ काम करता है।
RemoteFunction nil क्यों लौटाता है
अगर InvokeServer आपको nil देता है, तो इन बिंदुओं को क्रम से जाँचें:
- बिना return वैल्यू वाला रास्ता।
OnServerInvokeसे हर निकास को कुछ लौटाना चाहिए। शुरुआती जाँच में ख़ालीreturnवापसnilभेजता है। - अंदर के फ़ंक्शन में return।
pcall(function() ... end),:Connectहैंडलर याtask.spawnके अंदर काreturnसिर्फ़ उसी अंदर के फ़ंक्शन से निकलता है। नतीजा सेव करें, जैसेlocal ok, data = pcall(...), और फिर callback से हीdataलौटाएँ। - ऐसी वैल्यू जो सीमा पार नहीं कर सकती। फ़ंक्शन या ऐसा Instance जो क्लाइंट को नहीं दिखता (जैसे ServerStorage में कुछ भी)
nilबनकर आता है। instance streaming चालू होने पर, सर्वर का अभी बनाया पार्ट फ़ंक्शन के लौटने तक शायद क्लाइंट तक न पहुँचा हो। - Callback किसी दूसरी स्क्रिप्ट ने सेट किया। सिर्फ़
OnServerInvokeका आख़िरी assignment काम करता है। अपनी स्क्रिप्ट्स में remote का नाम खोजें।
अगर कॉल लौटती ही नहीं, तो या तो किसी स्क्रिप्ट ने अभी तक OnServerInvoke सेट नहीं किया (Roblox सेट होने तक कॉल्स को कतार में रखता है), या callback अटका है, जैसे किसी ऐसी चीज़ के WaitForChild पर जो कभी नहीं आएगी।
UnreliableRemoteEvent: लगातार आने वाले एक बार के अपडेट के लिए
UnreliableRemoteEvent के वही मेथड और इवेंट हैं जो RemoteEvent के: FireServer, FireClient, FireAllClients, OnServerEvent और OnClientEvent। फ़र्क़ यह है कि Roblox न पहुँचने की गारंटी देता है न क्रम की। संदेश बिना दोबारा भेजे छोड़ा जा सकता है, जब:
- वह रास्ते में खो जाए या भरे हुए नेटवर्क में बहुत देर इंतज़ार करे
- उसका डेटा 1000 बाइट से बड़ा हो
- क्लाइंट सीमा से ज़्यादा बार भेजे (ज़्यादा वाले छोड़ दिए जाते हैं, टाले नहीं जाते)
- पहुँचने के समय कोई हैंडलर जुड़ा न हो (वह फेंक दिया जाता है, कतार में नहीं रखा जाता)
संदेश क्रम से बाहर भी आ सकते हैं, और उनके क्रम का आपके RemoteEvent या RemoteFunction से कोई संबंध नहीं। इसे तब इस्तेमाल करें जब सिर्फ़ सबसे ताज़ा वैल्यू मायने रखती हो और अगला अपडेट एक सेकंड के हिस्से में आ जाए: प्लेयर कहाँ निशाना लगा रहा है, कॉस्मेटिक इफ़ेक्ट की पोज़िशन, हर फ़्रेम बदलने वाली वैल्यू। अगर क्रम मायने रखता है, तो हर संदेश में क्रम संख्या या टाइमस्टैम्प डालें और आख़िरी संभाले गए से पुराना सब अनदेखा करें।
इसे कभी ऐसी चीज़ के लिए इस्तेमाल न करें जो ठीक एक बार होनी चाहिए, जैसे ख़रीदारी, डैमेज, इनाम या राउंड की शुरुआत। और इसके arguments सर्वर पर ठीक वैसे ही जाँचें जैसे RemoteEvent के।
पहुँचने का क्रम और दर की सीमाएँ
Roblox की डिलीवरी गारंटी एक कनेक्शन पर एक दिशा में लागू होती है: सर्वर से एक क्लाइंट तक या एक क्लाइंट से सर्वर तक।
- RemoteEvent भरोसेमंद और क्रम में हैं। खोए संदेश तब तक दोबारा भेजे जाते हैं जब तक पाने वाला जुड़ा है, और संदेश उसी क्रम में पहुँचते हैं जिसमें आपने भेजे, अलग-अलग RemoteEvent के ज़रिए भी। अगर सर्वर प्लेयर को A, फिर B, फिर A भेजता है, तो उस प्लेयर को A, B, A मिलता है।
- क्रम हैंडलर्स के चलने के पल से जुड़ा है। अगर हैंडलर yield करता है, जैसे
task.waitयाWaitForChildसे, तो अगला संदेश पहले वाले के ख़त्म होने से पहले संभाला जाना शुरू हो सकता है। - RemoteFunction और RemoteEvent एक-दूसरे के सापेक्ष क्रम में नहीं हैं। अगर आपका कोड सख़्त क्रम पर टिका है, तो जुड़े संदेश एक ही तरह के remote से भेजें या अपनी क्रम संख्या जोड़ें।
- प्रॉपर्टी और attribute के बदलाव remotes के सापेक्ष क्रम में नहीं हैं। अगर सर्वर प्रॉपर्टी बदलता है और फिर remote कॉल करता है, तो क्लाइंट दोनों में से कोई भी पहले देख सकता है। बदलाव को ख़ुद सुनें, जैसे
GetPropertyChangedSignalसे, यह न मानें कि वह पहले ही आ चुका है। - हैंडलर अभी नहीं है। RemoteEvent संदेश हैंडलर जुड़ने तक कतार में रहते हैं। कतार की सीमा है: भर जाने पर अगले संदेश छोड़ दिए जाते हैं, और Output में
Remote event invocation discardedएरर आता है। - जो प्लेयर जा रहा है, वह सब संदेश खो देता है जो अभी उस तक नहीं पहुँचे।
दर की सीमा। क्लाइंट से सर्वर तक RemoteEvent और UnreliableRemoteEvent संदेश लगभग हर क्लाइंट पर प्रति सेकंड 500 अनुरोध तक सीमित हैं, 30 सितंबर 2026 के डॉक्यूमेंटेशन के अनुसार। सीमा एक ही तरह के सब remotes के लिए साझा है, इसलिए एक व्यस्त remote को दस में बाँटने से यह नहीं बढ़ती। सीमा से ऊपर RemoteEvent संदेश बाद में संभाले जाते हैं और क्रम बना रहता है, और UnreliableRemoteEvent संदेश छोड़ दिए जाते हैं। इंजन की सीमा एक प्लेयर को आपका remote प्रति सेकंड 50 बार कॉल करने से बिल्कुल नहीं रोकती, इसलिए कुछ बदलने वाले हर हैंडलर को फिर भी हर प्लेयर पर अपनी सीमा चाहिए।
RemoteEvent, RemoteFunction, UnreliableRemoteEvent या attribute?
| इस्तेमाल करें | किसलिए | उदाहरण | किस पर ध्यान दें |
|---|---|---|---|
| RemoteEvent | एक तरफ़ के संदेश जो पहुँचने चाहिए, और क्रम में | क्लाइंट: "यह पार्ट रंगो"। सर्वर: "यह नोटिफ़िकेशन दिखाओ" | सर्वर पर हर argument जाँचें |
InvokeServer के साथ RemoteFunction | आगे बढ़ने से पहले क्लाइंट को जवाब चाहिए | प्रोमो कोड डालना, ख़रीद की पुष्टि | कॉल करने वाला इंतज़ार करता है; हर रास्ते को वैल्यू लौटानी चाहिए |
InvokeClient के साथ RemoteFunction | लगभग कभी नहीं | इसकी जगह FireClient इस्तेमाल करें | जिस क्लाइंट में एरर हो, जो चला जाए या जवाब न दे, वह सर्वर पर कॉल तोड़ता या अटकाता है |
| UnreliableRemoteEvent | बार-बार के अपडेट जहाँ सिर्फ़ आख़िरी मायने रखता है | निशाने की दिशा, कॉस्मेटिक इफ़ेक्ट | संदेश खोते हैं या क्रम बदलते हैं; डेटा की सीमा 1000 बाइट |
| सर्वर से सेट attribute या value ऑब्जेक्ट | साझा स्टेट जो हमेशा दिखनी चाहिए, बाद में आए प्लेयर्स को भी | राउंड टाइमर, गेम का चरण, दरवाज़ा खुला है या नहीं | सब तक सिर्फ़ सर्वर के बदलाव पहुँचते हैं; क्लाइंट GetAttributeChangedSignal या Changed से सुनते हैं |
| BindableEvent | एक ही तरफ़ की स्क्रिप्ट्स की बातचीत | एक सर्वर स्क्रिप्ट दूसरी को बताती है कि राउंड ख़त्म हुआ | सर्वर और क्लाइंट के बीच नहीं जाता |
RemoteFunction और जाँचें वहाँ साथ कैसे काम करती हैं जहाँ प्लेयर्स पैसे देते हैं, इसका पूरा उदाहरण शॉप GUI कैसे बनाएँ गाइड में देखें। Attributes वाली पंक्ति के लिए, दरवाज़ों की गाइड की सर्वर स्क्रिप्ट हर दरवाज़े पर उसकी हर हरकत पर Open attribute सेट करती है, ताकि कोई भी LocalScript उस पर प्रतिक्रिया दे सके।
आम गलतियाँ और उनके हल
Remotes की ज़्यादातर समस्याएँ Output विंडो में दिखती हैं (इसे Window मेन्यू या Script टैब से खोलें)। पहले वहाँ देखें, फिर नीचे अपना लक्षण ढूँढें। स्क्रिप्ट एरर गाइड आम एरर संदेशों को और विस्तार से समझाती है।
Remote के WaitForChild पर Infinite yield possible
स्क्रिप्ट ऐसे remote का इंतज़ार कर रही है जो कभी नहीं आएगा। जाँचें कि नाम और अक्षरों का केस हूबहू मेल खाते हैं और remote ReplicatedStorage में है, ServerStorage या ServerScriptService में नहीं, जो क्लाइंट को नहीं दिखते।
सर्वर को ग़लत वैल्यू मिलती हैं, एक से खिसकी हुई
LocalScript ने ख़ुद प्लेयर भेज दिया, जैसे remote:FireServer(player, 5) में। Roblox भेजने वाले को पहले parameter के रूप में वैसे भी जोड़ता है, इसलिए सर्वर (player, player, 5) देखता है। remote:FireServer(5) कॉल करें।
Remote कॉल करने पर कुछ नहीं होता
जाँचें कि हर कॉल सही तरफ़ से हो रही है: FireServer और InvokeServer सिर्फ़ क्लाइंट कोड से काम करते हैं, और FireClient, FireAllClients और InvokeClient सिर्फ़ सर्वर Script से। LocalScript ServerScriptService, ServerStorage या सीधे Workspace में कभी नहीं चलता; उसे StarterPlayerScripts, StarterGui, StarterCharacterScripts या StarterPack में रखें। फिर Output में हैंडलर के अंदर का एरर ढूँढें।
Remote event invocation discarded
ऐसे RemoteEvent के लिए संदेश आए जिसका कोई हैंडलर जुड़ा नहीं था, और कतार भर गई। आमतौर पर हैंडलर वाली स्क्रिप्ट :Connect वाली लाइन से पहले एरर से रुक जाती है, बंद है, या किसी ऐसी चीज़ के इंतज़ार में अटकी है जो कभी लोड नहीं होगी। हैंडलर स्क्रिप्ट की शुरुआत के पास जोड़ें।
मेरे लिए काम करता है, पर दूसरे प्लेयर्स बदलाव नहीं देखते
बदलाव क्लाइंट पर हुआ, LocalScript में या OnClientEvent हैंडलर में। इसे सर्वर के OnServerEvent हैंडलर में करें।
InvokeServer कभी नहीं लौटता
या तो किसी स्क्रिप्ट ने OnServerInvoke सेट नहीं किया (Roblox सेट होने तक कॉल्स को कतार में रखता है), या callback किसी yield करने वाली चीज़ पर अटका है, जैसे WaitForChild या DataStore का अनुरोध। callback की शुरुआत और अंत में print जोड़ें, ताकि दिखे कि वह कहाँ रुकता है।
RoCode के साथ बनाएँ
यह RoCode भी सेट कर सकता है, सीधे आपके खुले place में। RoCode एक AI एजेंट है जो Roblox Studio प्लगइन के ज़रिए काम करता है, इसलिए वह आपके Explorer में remotes और स्क्रिप्ट बनाता है, पेस्ट करने के लिए कोड नहीं देता।
प्लेयर्स Paintable फ़ोल्डर के पार्ट्स क्लिक से रंग सकें। RemoteEvent इस्तेमाल करो और जाँचें सर्वर पर रखो: सिर्फ़ इस फ़ोल्डर के पार्ट्स, 30 studs से ज़्यादा दूर नहीं, और प्रति सेकंड कुछ से ज़्यादा रंगाई नहीं।
- आमतौर पर पहले Search Game और Search Scripts से place देखता है, तैयार Remotes फ़ोल्डर या हैंडलर की तलाश में, और अगर आपके फ़ोल्डर हैं तो उन्हें इस्तेमाल करता है
- Create Instance से ReplicatedStorage में RemoteEvent बनाता है और Create Script से सर्वर Script और LocalScript लिखता है
- ख़त्म करने से पहले Studio के अंदर Check Script से हर स्क्रिप्ट का कंपाइल जाँचता है। यह कंपाइल एरर पकड़ता है, लॉजिक की ग़लतियाँ नहीं: वह टाइप नहीं जाँचता, linter नहीं चलाता और आपका कोड नहीं चलाता
- बदलाव बैच में भेजता है, और हर बैच Studio की हिस्ट्री में एक undo पॉइंट है
प्लगइन 3.9 या नए के साथ RoCode छोटा playtest चला सकता है और एरर पढ़ सकता है, और प्लगइन 3.9.11 या नए के साथ एक टेस्ट कैरेक्टर चला सकता है, पर 3D विंडो में पार्ट्स पर क्लिक नहीं करता। ख़ुद Play दबाएँ और जाँचें तोड़ने की कोशिश करें, जैसे मैप के दूसरे छोर से पार्ट रंगकर। अगर एरर आए, तो Check Output आपके आख़िरी playtest की Server और Client लाइनें पढ़ सकता है। ज़्यादातर गेम सिस्टम ऐसे ही remotes से बात करते हैं, इसलिए ये फिर मिलेंगे जब आप RoCode के साथ सिस्टम दर सिस्टम गेम बनाएँगे। RoCode Studio से कैसे जुड़ता है।
अक्सर पूछे जाने वाले सवाल
Roblox में securing the client-server boundary का मतलब क्या है?
यह remotes की सुरक्षा पर Roblox डॉक्यूमेंटेशन के पेज का नाम है, और विचार सीधा है: क्लाइंट RemoteEvent या RemoteFunction से जो भी भेजता है वह exploiter से आ सकता है, इसलिए सर्वर कुछ करने से पहले उसे जाँचता है। हर argument का टाइप जाँचें, संख्याएँ उचित सीमाओं में रखें, जाँचें कि प्लेयर को अभी यह करने की इजाज़त है, और सीमित करें कि हर प्लेयर remote कितनी बार कॉल कर सकता है। ऊपर की जाँच की चेकलिस्ट इनमें से हर एक को कोड में दिखाती है।
क्या RemoteFunction इस्तेमाल करना सुरक्षित है?
InvokeServer उतना ही सुरक्षित है जितना आपका सर्वर callback: उसके arguments जाँचें और दर सीमित करें, जैसे किसी भी RemoteEvent के लिए। जोखिम वाली दिशा InvokeClient है, क्योंकि जिस क्लाइंट में एरर हो, जो चला जाए या कभी वैल्यू न लौटाए, वह सर्वर पर कॉल तोड़ता या अटकाता है।
क्या exploiters मेरे remotes देख और कॉल कर सकते हैं?
हाँ। ReplicatedStorage की हर चीज़ हर क्लाइंट तक पहुँचती है, और बदला हुआ क्लाइंट कोई भी remote किसी भी arguments के साथ कॉल कर सकता है। Remotes का नाम बदलना या उन्हें छिपाना उन्हें सुरक्षित नहीं बनाता; सर्वर पर हर argument की जाँच उन्हें सुरक्षित बनाती है।
क्या एक क्लाइंट दूसरे क्लाइंट को RemoteEvent भेज सकता है?
सीधे नहीं। उसे सर्वर पर भेजें, वहाँ जाँचें, फिर FireClient या FireAllClients इस्तेमाल करें।
RemoteEvent कितनी बार कॉल किया जा सकता है?
Roblox डॉक्यूमेंटेशन सर्वर को भेजे गए RemoteEvent और UnreliableRemoteEvent संदेशों के लिए लगभग हर क्लाइंट पर प्रति सेकंड 500 अनुरोधों की सीमा बताता है, जो एक ही तरह के सब remotes में साझा है। इससे बहुत नीचे रहें और हर हैंडलर को हर प्लेयर पर अपनी सीमा दें।
क्या FireAllClients बाद में आए प्लेयर्स तक पहुँचता है?
नहीं। यह उस पल जुड़े प्लेयर्स तक पहुँचता है। देर से आने वालों को जो स्टेट चाहिए, उसके लिए सर्वर पर attribute या value ऑब्जेक्ट सेट करें।
RemoteEvent और BindableEvent में क्या फ़र्क़ है?
RemoteEvent सर्वर और क्लाइंट के बीच जाता है। BindableEvent एक ही तरफ़ की स्क्रिप्ट्स को जोड़ता है, जैसे दो सर्वर स्क्रिप्ट।
स्रोत और आगे पढ़ें
- Roblox Creator Docs: Remote events and callbacks (अंग्रेज़ी में). FireServer, FireClient, InvokeServer, InvokeClient के जोखिम, arguments की सीमाएँ और डिलीवरी गारंटी
- 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 के बीच replication का क्रम
कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।