ट्यूटोरियल · स्क्रिप्टिंग की बुनियाद

Roblox में RemoteEvent: क्लाइंट से सर्वर और वापस

LocalScript वह नहीं बदल सकता जो दूसरे प्लेयर्स देखते हैं, और सर्वर Script किसी एक प्लेयर की स्क्रीन तक नहीं पहुँच सकती। इनके बीच संदेश RemoteEvent पहुँचाते हैं। इस गाइड में हम तीन पैटर्न बनाएँगे जिनकी आपको सबसे ज़्यादा ज़रूरत पड़ेगी, एक RemoteFunction जो जवाब लौटाता है, और सर्वर की वे जाँचें जो बदले हुए क्लाइंट को उनका ग़लत इस्तेमाल नहीं करने देतीं।

अपडेट किया गया 20 नवंबर 202620 मिनट में पढ़ेंलेखक:

संक्षेप में

RemoteEvent एक ऑब्जेक्ट है जो आमतौर पर ReplicatedStorage में रहता है और क्लाइंट और सर्वर की सीमा के पार संदेश पहुँचाता है। LocalScript FireServer कॉल करता है, और सर्वर को संदेश OnServerEvent में मिलता है, जहाँ पहले argument के रूप में भेजने वाला Player जुड़ा होता है। सर्वर FireClient(player, ...) या FireAllClients(...) कॉल करता है, और LocalScript को संदेश OnClientEvent में मिलता है।

  • RemoteFunction (InvokeServer और OnServerInvoke) तभी इस्तेमाल करें जब क्लाइंट को जवाब चाहिए। InvokeClient से बचें: जिस क्लाइंट में एरर आए, जो चला जाए या कभी वैल्यू न लौटाए, वह सर्वर पर कॉल तोड़ देता है।
  • क्लाइंट जो भेजता है उस पर कभी भरोसा न करें। सर्वर पर हर argument का टाइप, रेंज और ओनरशिप, प्लेयर की दूरी, और वह remote कितनी बार कॉल करता है, यह सब जाँचें।
  • फ़ंक्शन, metatables और वे ऑब्जेक्ट जो दूसरी तरफ़ नहीं दिखते, भेजे जाने के बाद नहीं बचते। 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. स्रोत और आगे पढ़ें

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 हमेशा इंतज़ार करता रहेगा।

  1. Explorer में ReplicatedStorage पर कर्सर ले जाएँ, + बटन दबाएँ और एक Folder डालें। फ़ोल्डर का नाम Remotes रखें।
  2. Remotes पर कर्सर ले जाएँ, + दबाएँ और एक RemoteEvent डालें। उसका नाम ऐसा रखें जो उसका काम बताए, जैसे PaintRequest।
  3. हर remote के लिए दोहराएँ। इस गाइड में दो RemoteEvent (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 रखें: तब हर सर्वर हैंडलर arguments का एक ही रूप जाँचता है, और सब कामों के लिए एक remote की तुलना में यह सही करना बहुत आसान है।

पैटर्न 1: क्लाइंट से सर्वर, सर्वर पर जाँच के साथ

सबसे आम काम: प्लेयर अपनी स्क्रीन पर कुछ करता है, और सर्वर तय करता है कि क्या होगा। यहाँ प्लेयर चार रंगों में से एक चुनने के लिए Q दबाता है और किसी पार्ट को रंगने के लिए उस पर क्लिक या टैप करता है। नया रंग सब देखते हैं, क्योंकि रंगने का काम सर्वर करता है।

क्लाइंट दो चीज़ें भेजता है: कौन सा पार्ट और रंग का नंबर। रंग ख़ुद वह कभी नहीं भेजता, और दूसरे गेम्स में भी उसे इसी तरह कीमत, इनाम या डैमेज की मात्रा नहीं भेजनी चाहिए। बदला हुआ क्लाइंट कुछ भी भेज सकता है, इसलिए असली डेटा (यहाँ रंगों की palette) सर्वर रखता है, और arguments को वह एक अनुरोध मानता है जिसे जाँचना है।

  1. Workspace में Paintable नाम का Folder डालें और उसमें कुछ anchored Part रखें।
  2. जाँचें कि ReplicatedStorage.Remotes में PaintRequest नाम का RemoteEvent है।
  3. ServerScriptService में PaintServer नाम की Script और StarterPlayer, StarterPlayerScripts में PaintClient नाम की LocalScript डालें, नीचे के कोड के साथ।
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
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 करती है। चीटर क्लाइंट को यह समझाने की कोई ज़रूरत नहीं कि उसे मना क्यों किया गया।

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

-- किरण सिर्फ़ 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 सेट करने की ज़रूरत नहीं।

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)
	-- पहला 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
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 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 जोड़ें।

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

	-- हर जुड़ा क्लाइंट इस टेक्स्ट के साथ अपना 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 सुझाता है, क्योंकि वह इंतज़ार नहीं करता।

उदाहरण: एक बॉक्स जिसमें प्लेयर्स प्रोमो कोड डालते हैं। सर्वर कोड रखता है, टेक्स्ट जाँचता है और दो वैल्यू लौटाता है: काम किया या नहीं, और दिखाने वाला संदेश।

  1. ReplicatedStorage.Remotes में RedeemCode नाम का RemoteFunction डालें।
  2. StarterGui में CodeGui नाम का ScreenGui डालें, और उसके अंदर CodeBox नाम का TextBox। साइज़ और जगह अपनी पसंद से चुनें।
  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 } = {}

-- = से 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 में रखें।

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 होता है। अगर दो स्क्रिप्ट एक ही 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 हैंडलर में इस्तेमाल किया जा सकता है।

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 के बीच का पूर्णांक, मात्राओं, 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 का कंटेंट बदल दें:

Script स्थान: ServerScriptService नाम: 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, और इन सबसे बनी टेबल भेजी जा सकती हैं। कुछ वैल्यू रास्ते में बदल जाती हैं या ग़ायब हो जाती हैं:

Arguments जो भेजे गए रूप में नहीं पहुँचते
आप भेजते हैंक्या होता है
फ़ंक्शनदूसरी तरफ़ को nil मिलता है
Metatable वाली टेबलMetatable खो जाती है, और साथ में वह सब जो टेबल के पास सिर्फ़ उसके ज़रिए था
ऐसी टेबल जिसमें नंबर और स्ट्रिंग keys मिली होंRoblox ऐसा न करने की सलाह देता है: साफ़ array या साफ़ dictionary भेजें
अंदर nil वैल्यू वाली टेबलबचें: Roblox किसी भी index पर nil की सलाह नहीं देता
Instance, userdata या function टाइप की keys वाली टेबलऐसी keys स्ट्रिंग में बदल जाती हैं
ऐसा Instance जो पाने वाले को नहीं दिखता, जैसे ServerStorage से या LocalScript में बनाया हुआदूसरी तरफ़ को nil मिलता है
कोई भी टेबलपाने वाले को एक कॉपी मिलती है, वही टेबल नहीं

एक अच्छी आदत: ऑब्जेक्ट या वैल्यू नहीं, पहचान भेजें। आइटम का नाम, विकल्प का नंबर, एक पार्ट जिसे सर्वर ढूँढ और जाँच सके। आगे सर्वर अपने डेटा के साथ काम करता है।

RemoteFunction nil क्यों लौटाता है

अगर InvokeServer आपको nil देता है, तो इन बिंदुओं को क्रम से जाँचें:

  1. बिना return वैल्यू वाला रास्ता। OnServerInvoke से हर निकास को कुछ लौटाना चाहिए। शुरुआती जाँच में ख़ाली return वापस nil भेजता है।
  2. अंदर के फ़ंक्शन में return। pcall(function() ... end), :Connect हैंडलर या task.spawn के अंदर का return सिर्फ़ उसी अंदर के फ़ंक्शन से निकलता है। नतीजा सेव करें, जैसे local ok, data = pcall(...), और फिर callback से ही data लौटाएँ।
  3. ऐसी वैल्यू जो सीमा पार नहीं कर सकती। फ़ंक्शन या ऐसा Instance जो क्लाइंट को नहीं दिखता (जैसे ServerStorage में कुछ भी) nil बनकर आता है। instance streaming चालू होने पर, सर्वर का अभी बनाया पार्ट फ़ंक्शन के लौटने तक शायद क्लाइंट तक न पहुँचा हो।
  4. 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 से ज़्यादा दूर नहीं, और प्रति सेकंड कुछ से ज़्यादा रंगाई नहीं।

RoCode करता है
  • आमतौर पर पहले 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 API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।

अपने गेम में RoCode आज़माएँ।

हर दिन मुफ़्त क्रेडिट, कार्ड की ज़रूरत नहीं। प्लगइन इंस्टॉल करें, फ़ीचर बताएँ और देखें कि Studio में क्या बना।