ट्यूटोरियल · गेम सिस्टम

Roblox Studio में राउंड सिस्टम कैसे बनाएं

Roblox के ज़्यादातर राउंड वाले गेम एक ही लूप चलाते हैं: प्लेयर का इंतज़ार, शून्य तक गिनती, मैप लोड करना, सबको वहाँ टेलीपोर्ट करना, टाइमर चलाना, विजेता चुनना और सफ़ाई करना। इस गाइड में हम यह लूप एक साफ़-सुथरी सर्वर स्क्रिप्ट के रूप में बनाते हैं, एक टाइमर जोड़ते हैं जो हर प्लेयर देखता है, और उन हालात को समझते हैं जिन पर कॉपी की हुई स्क्रिप्ट टूट जाती हैं: प्लेयर जो राउंड के बीच में मरते हैं, निकल जाते हैं या जॉइन करते हैं।

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

संक्षेप में

ServerScriptService में एक सर्वर Script लिखें, जो बार-बार तय स्टेट्स से गुज़रे: इंटरमिशन (ज़रूरी संख्या में प्लेयर का इंतज़ार, फिर उलटी गिनती), मैप लोड (ServerStorage से एक रैंडम मैप Workspace में क्लोन करना), टेलीपोर्ट (हर ज़िंदा कैरेक्टर को PivotTo से स्पॉन पार्ट पर ले जाना), राउंड (टाइमर चलाना जब तक समय ख़त्म न हो या एक ही प्लेयर या एक ही टीम न बचे) और सफ़ाई (Wins देना, बचे हुए प्लेयर को respawn करना, मैप हटाना)।

  • लूप सिर्फ़ सर्वर पर चलाएँ। स्टेटस और बचे हुए सेकंड ReplicatedStorage के एक Folder पर attributes के रूप में पब्लिश करें, और उन्हें दिखाने का काम LocalScript करे।
  • उन प्लेयर की एक टेबल रखें जो अभी राउंड में हैं। प्लेयर को तब हटाएँ जब उसका Humanoid मरे, उसका कैरेक्टर हटे या वह गेम छोड़ दे।
  • सिर्फ़ उन्हीं प्लेयर को टेलीपोर्ट करें जिनका कैरेक्टर राउंड शुरू होते समय ज़िंदा है। जो बाद में आए, वे अगले राउंड के लिए लॉबी में रुकें।
इस पेज पर
  1. यह कैसे काम करता है
  2. 1. लॉबी और मैप
  3. 2. राउंड स्क्रिप्ट
  4. स्टेट कैसे काम करते हैं
  5. 3. टाइमर UI
  6. राउंड के बीच प्लेयर
  7. कैसे बढ़ाएँ
  8. Common errors
  9. RoCode के साथ
  10. अक्सर पूछे जाने वाले सवाल
  11. स्रोत और आगे पढ़ें

राउंड सिस्टम कैसे काम करता है

उदाहरणचलते गेम में तैयार राउंड स्क्रिप्ट, तेज़ की हुई।

राउंड सिस्टम एक स्टेट मशीन है। किसी भी पल सर्वर ठीक एक स्टेट में होता है, हर स्टेट का एक काम होता है, और एक शर्त उसे अगले स्टेट में ले जाती है। ऐसे लिखने पर पूरा लॉजिक एक जगह रहता है, और वह मशहूर बग नहीं आता जिसमें टाइमर लूप और राउंड लूप दोनों एक ही राउंड को ख़त्म करने की कोशिश करते हैं।

इस गाइड में राउंड लूप के स्टेट
स्टेटसर्वर क्या करता हैअगले स्टेट में कब जाता है
Waiting"Waiting for players (1/2)" दिखाता हैसर्वर पर काफ़ी प्लेयर हैं
Intermissionसबके लॉबी में रहते समय गिनती करता हैगिनती ख़त्म (या प्लेयर निकल जाएँ तो वापस Waiting)
Startingएक रैंडम मैप Workspace में कॉपी करता है, उसका नाम दिखाता है, क्लाइंट से उसे लोड करने को कहता है"तैयार हो जाइए" की छोटी गिनती ख़त्म
InRoundज़िंदा प्लेयर को टेलीपोर्ट करता है, टाइमर चलाता है, मरने या निकलने वालों को हटाता हैसमय ख़त्म, या एक ही प्लेयर या एक ही टीम बची
Resultsहर ज़िंदा प्लेयर को Win देता है और दिखाता है कि कौन जीताकुछ सेकंड बीत गए
Cleanupबचे हुए प्लेयर को लॉबी में respawn करता है और मैप हटाता हैतुरंत, फिर लूप दोबारा शुरू होता है

हर स्टेट सर्वर के हाथ में है। क्लाइंट सिर्फ़ वही दिखाते हैं जो सर्वर उन्हें बताता है। LocalScript में चलने वाली गिनती असली गिनती से अलग हो जाती है, बाद में आने वालों के लिए ग़लत होती है, और कोई exploiter उसे बदल सकता है। अगर सर्वर और क्लाइंट का बँटवारा आपके लिए नया है, तो पहले Script vs LocalScript vs ModuleScript पढ़ें।

स्टेप 1: लॉबी, मैप और Wins स्टैट बनाएँ

  1. Workspace में SpawnLocation के साथ एक लॉबी बनाएँ। देखें कि उसकी Neutral प्रॉपर्टी चालू है, ताकि हर प्लेयर यहीं स्पॉन हो, यहीं इंतज़ार करे और बाहर होने के बाद यहीं लौटे।
  2. ServerStorage में Maps नाम का एक Folder डालें। ServerStorage की चीज़ें कभी प्लेयर को नहीं भेजी जातीं, इसलिए जो मैप इस्तेमाल नहीं हो रहे, उनका उन पर कोई बोझ नहीं पड़ता।
  3. हर मैप को Maps के अंदर एक Model के रूप में बनाएँ, जिसके पार्ट Anchored हों। उसे लॉबी से दूर बनाएँ (कुछ सौ studs काफ़ी हैं), क्योंकि कॉपी ठीक वहीं दिखती है जहाँ आपने उसे बनाया था, और बाहर हुए प्लेयर वापस अंदर न जा पाएँ।
  4. हर मैप के अंदर Spawns नाम का एक Folder जोड़ें, और उसमें हर संभावित प्लेयर के लिए एक Anchored Part। उनकी Transparency 1 करें और CanCollide बंद करें, ताकि कोई उन्हें न देखे और न उनसे टकराए।
इस गाइड के बाद Explorer
Workspace
  Lobby Model
    SpawnLocation SpawnLocation
ServerStorage
  Maps Folder new
    Desert Model new
      Spawns Folder new
        Spawn1 Part new
        Spawn2 Part new
    Castle Model new
      Spawns Folder new
ServerScriptService
  Leaderstats Script new
  RoundSystem Script new
StarterGui
  RoundHud ScreenGui new
    RoundHudClient LocalScript new

राउंड स्क्रिप्ट प्लेयर के leaderstats फ़ोल्डर के अंदर Wins नाम की IntValue में 1 जोड़ती है। अगर आपके गेम में अभी leaderstats नहीं है, तो यह छोटी स्क्रिप्ट जोड़ें। अगर पहले से है, जैसे लीडरबोर्ड गाइड का सेव करने वाला वर्ज़न, तो इसे छोड़ दें: leaderstats बनाने वाली दो स्क्रिप्ट हर प्लेयर को दो फ़ोल्डर दे देती हैं।

Script स्थान: ServerScriptService नाम: Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- नाम ठीक यही होना चाहिए, छोटे अक्षरों में

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Studio में आप इस स्क्रिप्ट के चलने से पहले जॉइन कर सकते हैं, इसलिए जो पहले से यहाँ हैं उन सबको सेट करते हैं
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

प्लेयर के निकलने पर ये Wins रीसेट हो जाते हैं। इन्हें सेशन के बीच सेव रखने के लिए लीडरबोर्ड गाइड का DataStore वाला वर्ज़न लें।

स्टेप 2: राउंड स्क्रिप्ट जोड़ें

ServerScriptService में एक Script डालें, उसका नाम RoundSystem रखें और नीचे का कोड पेस्ट करें। ऊपर की सेटिंग्स ही वे लाइनें हैं जिन्हें आपको शायद बदलना पड़ेगा। हर स्टेट एक अलग फ़ंक्शन है, और नीचे का लूप उन्हें क्रम से, लगातार चलाता है।

Script स्थान: ServerScriptService नाम: RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- सेटिंग्स
local MIN_PLAYERS = 2 -- अकेले टेस्ट करते समय 1 रखें
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: राउंड तब ख़त्म होता है जब प्लेयर सिर्फ़ एक टीम में बचे हों

local mapsFolder = ServerStorage:WaitForChild("Maps")
local random = Random.new()

-- हर प्लेयर की स्क्रीन जो दिखाती है, वह इस फ़ोल्डर के attributes में रहता है।
-- सर्वर के सेट किए attributes सभी क्लाइंट तक replicate होते हैं, बाद में आने वालों तक भी।
local roundInfo = Instance.new("Folder")
roundInfo.Name = "RoundInfo"
roundInfo.Parent = ReplicatedStorage

local function setState(state: string, status: string)
	roundInfo:SetAttribute("State", state)
	roundInfo:SetAttribute("Status", status)
	roundInfo:SetAttribute("TimeLeft", 0)
end

local function setTimeLeft(seconds: number)
	roundInfo:SetAttribute("TimeLeft", seconds)
end

-- कौन अभी मौजूदा राउंड में है, और हर एक पर नज़र रखने वाले कनेक्शन
local alive: { [Player]: boolean } = {}
local watchers: { [Player]: { RBXScriptConnection } } = {}

local function eliminate(player: Player)
	if not alive[player] then
		return
	end
	alive[player] = nil
	player:SetAttribute("InRound", false)
	local connections = watchers[player]
	if connections then
		for _, connection in connections do
			connection:Disconnect()
		end
		watchers[player] = nil
	end
end

Players.PlayerRemoving:Connect(eliminate)

-- कैरेक्टर और Humanoid लौटाता है, सिर्फ़ अगर प्लेयर अभी ज़िंदा है
local function getLivingCharacter(player: Player): (Model?, Humanoid?)
	local character = player.Character
	if not character or not character.Parent then
		return nil, nil
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or not humanoid.RootPart then
		return nil, nil
	end
	return character, humanoid
end

-- राउंड में बचे पक्ष गिनता है (प्लेयर, या टीमें अगर USE_TEAMS चालू है)
local function countSides(): (number, number)
	local sides: { [Instance]: boolean } = {}
	local sideCount = 0
	local playerCount = 0
	for player in alive do
		playerCount += 1
		local team = player.Team
		local side: Instance = if USE_TEAMS and team then team else player
		if not sides[side] then
			sides[side] = true
			sideCount += 1
		end
	end
	return sideCount, playerCount
end

-- स्टेट: Waiting और Intermission। अगर गिनती के दौरान प्लेयर निकल गए तो false लौटाता है।
local function runIntermission(): boolean
	while #Players:GetPlayers() < MIN_PLAYERS do
		setState("Waiting", `Waiting for players ({#Players:GetPlayers()}/{MIN_PLAYERS})`)
		task.wait(1)
	end
	setState("Intermission", "Intermission")
	for secondsLeft = INTERMISSION_SECONDS, 1, -1 do
		if #Players:GetPlayers() < MIN_PLAYERS then
			return false
		end
		setTimeLeft(secondsLeft)
		task.wait(1)
	end
	return true
end

-- स्टेट: Starting, भाग 1। एक रैंडम मैप कॉपी करते हैं (पिछला नहीं, अगर चुनने का विकल्प है)।
local lastMapName = ""

local function loadMap(): Model?
	local allMaps: { Model } = {}
	local freshMaps: { Model } = {}
	for _, child in mapsFolder:GetChildren() do
		if child:IsA("Model") then
			table.insert(allMaps, child)
			if child.Name ~= lastMapName then
				table.insert(freshMaps, child)
			end
		end
	end
	local choices = if #freshMaps > 0 then freshMaps else allMaps
	if #choices == 0 then
		warn("RoundSystem: add at least one map Model to ServerStorage > Maps")
		return nil
	end
	local chosen = choices[random:NextInteger(1, #choices)]
	lastMapName = chosen.Name
	local map = chosen:Clone()
	map.Parent = workspace
	return map
end

local function getSpawnPoints(map: Model): { BasePart }
	local points: { BasePart } = {}
	local folder = map:FindFirstChild("Spawns")
	if folder then
		for _, child in folder:GetChildren() do
			if child:IsA("BasePart") then
				table.insert(points, child)
			end
		end
	end
	-- मिलाते हैं, ताकि प्लेयर हर राउंड एक ही स्पॉन पर न आएँ
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- खड़े कैरेक्टर का root part फ़र्श से कितनी ऊँचाई पर है।
-- Humanoid.HipHeight पर Roblox डॉक्यूमेंटेशन का फ़ॉर्मूला (R6 रिग में पैर की ऊँचाई जुड़ती है)।
local function rootHeight(character: Model, humanoid: Humanoid, rootPart: BasePart): number
	local height = rootPart.Size.Y / 2 + humanoid.HipHeight
	if humanoid.RigType == Enum.HumanoidRigType.R6 then
		local leg = character:FindFirstChild("Left Leg")
		if leg and leg:IsA("BasePart") then
			height += leg.Size.Y
		end
	end
	return height
end

-- स्टेट: Starting, भाग 2। तैयार होने का समय, फिर सभी ज़िंदा प्लेयर को टेलीपोर्ट करना।
local function startRound(map: Model): boolean
	local spawnPoints = getSpawnPoints(map)
	if #spawnPoints == 0 then
		warn(`RoundSystem: {map.Name} needs a Spawns folder with at least one part in it`)
		return false
	end

	-- streaming चालू होने पर हर क्लाइंट से कैरेक्टर पहुँचने से पहले मैप लोड करने को कहते हैं
	if workspace.StreamingEnabled then
		local mapPosition = map:GetPivot().Position
		for _, player in Players:GetPlayers() do
			task.spawn(function()
				pcall(function()
					player:RequestStreamAroundAsync(mapPosition, GET_READY_SECONDS)
				end)
			end)
		end
	end

	setState("Starting", `Map: {map.Name}`)
	for secondsLeft = GET_READY_SECONDS, 1, -1 do
		setTimeLeft(secondsLeft)
		task.wait(1)
	end

	-- सिर्फ़ वही भाग लेते हैं जो अभी ज़िंदा हैं। बाक़ी अगले राउंड का इंतज़ार करते हैं।
	local participants: { Player } = {}
	for _, player in Players:GetPlayers() do
		if getLivingCharacter(player) then
			table.insert(participants, player)
		end
	end
	if #participants < MIN_PLAYERS then
		setState("Waiting", "Not enough players, starting over")
		task.wait(2)
		return false
	end

	for index, player in participants do
		local character, humanoid = getLivingCharacter(player)
		local rootPart = if humanoid then humanoid.RootPart else nil
		if character and humanoid and rootPart then
			local spawnPart = spawnPoints[(index - 1) % #spawnPoints + 1]
			-- कैरेक्टर का pivot उसका root part है, इसलिए उसे पार्ट के ऊपर खड़े होने की ऊँचाई तक उठाते हैं
			local height = spawnPart.Size.Y / 2 + rootHeight(character, humanoid, rootPart)
			character:PivotTo(spawnPart.CFrame + Vector3.new(0, height, 0))
			alive[player] = true
			player:SetAttribute("InRound", true)
			watchers[player] = {
				humanoid.Died:Connect(function()
					eliminate(player)
				end),
				player.CharacterRemoving:Connect(function()
					eliminate(player)
				end),
			}
		end
	end
	return true
end

-- स्टेट: InRound। समय ख़त्म होने या एक ही पक्ष बचने पर ख़त्म होता है।
local function runRound()
	setState("InRound", "Round in progress")
	local startingSides = countSides()
	for secondsLeft = ROUND_SECONDS, 1, -1 do
		local _, playersLeft = countSides()
		roundInfo:SetAttribute("Status", `{playersLeft} left`)
		setTimeLeft(secondsLeft)
		task.wait(1)
		local sidesLeft = countSides()
		-- एक पक्ष से शुरू हुआ राउंड (अकेले टेस्ट) सिर्फ़ समय से या मौत से ख़त्म होता है
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- स्टेट: Results। जो भी अभी ज़िंदा है, वह जीतता है।
local function awardWin(player: Player)
	local leaderstats = player:FindFirstChild("leaderstats")
	local wins = leaderstats and leaderstats:FindFirstChild("Wins")
	if wins and wins:IsA("IntValue") then
		wins.Value += 1
	end
end

local function finishRound(): { Player }
	local sidesLeft = countSides()
	local winners: { Player } = {}
	for player in alive do
		table.insert(winners, player)
	end

	local message = `{#winners} players survived!`
	local firstTeam = if #winners > 0 then winners[1].Team else nil
	if #winners == 0 then
		message = "Nobody survived"
	elseif USE_TEAMS and sidesLeft == 1 and firstTeam then
		message = `{firstTeam.Name} wins!`
	elseif #winners == 1 then
		message = `{winners[1].DisplayName} wins!`
	end

	for _, player in winners do
		awardWin(player)
		eliminate(player) -- उन पर नज़र रखना बंद; सफ़ाई तक वे मैप पर रहते हैं
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- स्टेट: Cleanup। बचे हुए प्लेयर को लॉबी में वापस भेजते हैं, फिर मैप हटाते हैं।
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- अभी सर्वर पर है
			task.spawn(function()
				local ok, err = pcall(function()
					player:LoadCharacterAsync()
				end)
				if not ok then
					warn(`RoundSystem: could not respawn {player.Name}: {err}`)
				end
			end)
		end
	end
	map:Destroy()
end

-- लूप: एक चक्कर एक राउंड है
while true do
	if runIntermission() then
		local map = loadMap()
		if map then
			local survivors: { Player } = {}
			if startRound(map) then
				runRound()
				survivors = finishRound()
			end
			cleanup(map, survivors)
		else
			task.wait(5) -- अभी कोई मैप नहीं: थोड़ी देर में फिर कोशिश करेंगे
		end
	end
end

सब कुछ ज़रूरी यहीं, सर्वर पर होता है: कौन राउंड में है, टाइमर, विजेता और Wins। क्लाइंट को सिर्फ़ ReplicatedStorage.RoundInfo पर तीन attributes (State, Status और TimeLeft) और हर प्लेयर पर InRound attribute मिलता है।

हर स्टेट कैसे काम करता है

इंतज़ार और इंटरमिशन

runIntermission पहले लूप को तब तक रोके रखता है जब तक #Players:GetPlayers() MIN_PLAYERS तक न पहुँच जाए। फिर वह task.wait(1) से एक-एक सेकंड गिनता है और हर टिक पर प्लेयर की संख्या जाँचता है। अगर कोई निकल गया और सर्वर पर न्यूनतम से कम प्लेयर रह गए, तो वह false लौटाता है, और मुख्य लूप Waiting से दोबारा शुरू होता है, इसलिए राउंड कभी एक इंसान के साथ शुरू नहीं होता।

मैप चुनना और लोड करना

loadMap ServerStorage.Maps के सारे Model इकट्ठा करता है, अगर चुनने के लिए और मैप हैं तो पिछले राउंड का मैप हटा देता है, और Random:NextInteger से एक चुनता है। फिर मैप को Workspace में क्लोन करता है। ओरिजिनल ServerStorage में बिना बदले रहता है, इसलिए हर राउंड ताज़ा कॉपी से शुरू होता है: पिछले राउंड में प्लेयर ने जो तोड़ा या खिसकाया, वह सब ग़ायब हो जाता है।

नए places में instance streaming चालू रहती है: क्लाइंट के पास सिर्फ़ उसके कैरेक्टर के पास के पार्ट होते हैं। टेलीपोर्ट से पहले स्क्रिप्ट हर प्लेयर के लिए Player:RequestStreamAroundAsync कॉल करती है, जो इंजन से कहती है कि "तैयार हो जाइए" वाली गिनती के दौरान मैप के आसपास का इलाक़ा क्लाइंट को भेज दे। इसके बिना प्लेयर फ़र्श लोड होने से पहले पहुँच सकते हैं और एक पल के लिए अटक सकते हैं।

PivotTo से प्लेयर को टेलीपोर्ट करना

गिनती के बाद स्क्रिप्ट उन प्लेयर की लिस्ट बनाती है जिनका कैरेक्टर मौजूद है, अभी दुनिया में है, और जिसमें 0 से ज़्यादा health वाला Humanoid और root part है। यह जाँच गिनती के बाद होती है, इसलिए जो उसके दौरान मरा या निकला, वह लिस्ट में नहीं आता।

हर भाग लेने वाले को character:PivotTo(cframe) से ले जाया जाता है। Roblox डॉक्यूमेंटेशन PivotTo को स्क्रिप्ट से मॉडल हिलाने का मुख्य तरीक़ा बताता है, और यह कैरेक्टर के सारे हिस्से एक साथ हिलाता है। HumanoidRootPart.Position सेट करना ऐसा नहीं है: Roblox जोड़ों को ऐसे ठीक करता है कि सिर्फ़ वही एक हिस्सा हिलता है, और बाक़ी शरीर पीछे रह सकता है। कैरेक्टर का pivot उसका root part है, इसलिए टारगेट स्पॉन पार्ट का CFrame है, जिसे पार्ट की आधी ऊँचाई और उस ऊँचाई जितना ऊपर उठाया गया है जिस पर root part फ़र्श के ऊपर खड़ा रहता है। rootHeight इसे Roblox डॉक्यूमेंटेशन में Humanoid.HipHeight वाले फ़ॉर्मूले से गिनता है: root part की आधी ऊँचाई प्लस HipHeight, और R6 रिग में पैर की लंबाई भी। इससे स्केल किए हुए और कस्टम अवतार पार्ट में नहीं फँसते और ऊपर से उस पर नहीं गिरते। CFrame में रोटेशन भी शामिल है, इसलिए प्लेयर उसी तरफ़ देखते हैं जिधर स्पॉन पार्ट देखता है: पार्ट ऐसे घुमाएँ कि सब मैप के बीच की ओर देखें।

अगर प्लेयर स्पॉन पार्ट से ज़्यादा हैं, तो स्क्रिप्ट फिर से पहले पार्ट से शुरू करती है, और प्लेयर एक-दूसरे के ऊपर आ जाते हैं, इसलिए कम से कम उतने स्पॉन जोड़ें जितने आपके अधिकतम प्लेयर हैं।

अगर आप स्प्रिंट गाइड वाली स्पीड जाँच भी इस्तेमाल करते हैं, तो startRound में character:PivotTo(...) के ठीक बाद player:SetAttribute("MovementCheckSkip", true) जोड़ें, ताकि टेलीपोर्ट को स्पीड की सीमा तोड़ना न माना जाए।

राउंड टाइमर और ख़त्म होने की शर्तें

runRound हर सेकंड एक बार टिक करता है। हर टिक पर यह स्टेटस (कितने प्लेयर बचे) और बचे हुए सेकंड अपडेट करता है, फिर ज़िंदा पक्ष गिनता है। राउंड तीन में से किसी एक तरीक़े से ख़त्म होता है:

  • समय ख़त्म। for लूप 1 तक पहुँचकर ख़त्म हो जाता है।
  • एक ही पक्ष बचा। पक्ष एक प्लेयर है, या टीम, अगर USE_TEAMS चालू है। यह जाँच सिर्फ़ तब काम करती है जब राउंड दो या ज़्यादा पक्षों के साथ शुरू हुआ हो, इसलिए अकेले का टेस्ट शुरू होते ही ख़त्म नहीं हो जाता।
  • कोई नहीं बचा। सब मर गए या निकल गए, और राउंड बिना विजेता के ख़त्म होता है।

हर सेकंड एक बार जाँच का मतलब है कि आख़िरी प्लेयर के बाहर होने के बाद राउंड एक सेकंड तक और चल सकता है, जो राउंड टाइमर पर लगभग दिखता ही नहीं।

Wins देना और नतीजा दिखाना

इस स्क्रिप्ट का नियम आसान है: राउंड ख़त्म होते समय जो भी ज़िंदा है, वह जीतता है। यह आख़िरी बचे प्लेयर, आख़िरी बची टीम और "टाइमर ख़त्म होने तक टिके रहो" मोड, तीनों को लॉजिक की एक लाइन से संभाल लेता है। finishRound हर विजेता के Wins में 1 जोड़ता है, उन पर नज़र रखना बंद करता है और RESULTS_SECONDS तक "Alex wins!" जैसा मैसेज दिखाता है। अगर आप चाहते हैं कि समय ख़त्म होने पर कोई विजेता न हो, तो awardWin छोड़ दें और sidesLeft 1 से ज़्यादा होने पर मैसेज बदल दें। दोनों हालात में लिस्ट लौटाते रहें, क्योंकि सफ़ाई उसी से बचे हुए प्लेयर को लॉबी में लौटाती है।

सफ़ाई

बचे हुए प्लेयर अभी भी मैप पर खड़े हैं, इसलिए cleanup उन्हें Player:LoadCharacterAsync() से लॉबी में respawn करता है, जो पुराने LoadCharacter की जगह लेता है, फिर मैप की कॉपी हटा देता है। हर respawn pcall के अंदर अपने task.spawn में चलता है, क्योंकि यह कॉल कैरेक्टर के लोड होने का इंतज़ार करती है और अगर प्लेयर ठीक उसी पल निकल रहा हो तो फ़ेल हो सकती है। बाहर हुए प्लेयर के लिए कुछ नहीं करना होता: वे पहले ही ख़ुद लॉबी में respawn हो चुके हैं।

स्टेप 3: हर प्लेयर को टाइमर और स्टेटस दिखाएँ

सर्वर ReplicatedStorage.RoundInfo पर तीन attributes पब्लिश करता है: State (स्क्रिप्ट के लिए InRound जैसा तय शब्द), Status (इंसानों के लिए टेक्स्ट) और TimeLeft (सेकंड)। सर्वर स्क्रिप्ट किसी replicate होने वाले ऑब्जेक्ट पर जो attributes सेट करती है, वे अपने आप हर क्लाइंट तक पहुँच जाते हैं, और राउंड के बीच आने वाले प्लेयर को तुरंत मौजूदा वैल्यू मिल जाती हैं। इसलिए टाइमर के लिए यह remote से बेहतर है: किसी के आने से पहले भेजा गया RemoteEvent उस तक कभी नहीं पहुँचेगा।

  1. Explorer में StarterGui के अंदर एक ScreenGui डालें और उसका नाम RoundHud रखें। ResetOnSpawn चालू रहने दें (डिफ़ॉल्ट)।
  2. RoundHud में एक LocalScript डालें, उसका नाम RoundHudClient रखें और नीचे का कोड पेस्ट करें। यह ख़ुद लेबल बनाती है, इसलिए और कुछ बनाने की ज़रूरत नहीं।
  3. Play दबाएँ। स्क्रीन के ऊपर का लेबल स्टेटस और m:ss फ़ॉर्मेट में गिनती दिखाता है।
LocalScript स्थान: StarterGui में ScreenGui RoundHud नाम: RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local roundInfo = ReplicatedStorage:WaitForChild("RoundInfo")
local screenGui = script.Parent :: ScreenGui

-- लेबल। अगर आपने RoundHud में अपना TextLabel बनाया है, तो यह ब्लॉक हटाएँ और इस्तेमाल करें:
-- local label = screenGui:WaitForChild("StatusLabel") :: TextLabel
local label = Instance.new("TextLabel")
label.Name = "StatusLabel"
label.AnchorPoint = Vector2.new(0.5, 0)
label.Position = UDim2.new(0.5, 0, 0, 12)
label.Size = UDim2.fromOffset(320, 44)
label.BackgroundColor3 = Color3.fromRGB(20, 14, 32)
label.BackgroundTransparency = 0.2
label.TextColor3 = Color3.new(1, 1, 1)
label.Font = Enum.Font.BuilderSansBold
label.TextSize = 22
label.TextWrapped = true -- लंबे मैसेज दूसरी लाइन में चले जाते हैं
label.Text = ""
label.Parent = screenGui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = label

local function formatTime(seconds: number): string
	return string.format("%d:%02d", seconds // 60, seconds % 60)
end

local function update()
	local status = roundInfo:GetAttribute("Status")
	local timeLeft = roundInfo:GetAttribute("TimeLeft")
	local text = if type(status) == "string" then status else ""
	if type(timeLeft) == "number" and timeLeft > 0 then
		text ..= "   " .. formatTime(timeLeft)
	end
	label.Text = text
end

roundInfo:GetAttributeChangedSignal("Status"):Connect(update)
roundInfo:GetAttributeChangedSignal("TimeLeft"):Connect(update)
update()

क्योंकि ResetOnSpawn चालू है, Roblox हर बार कैरेक्टर स्पॉन होने पर प्लेयर को RoundHud की ताज़ा कॉपी देता है, सफ़ाई के समय के respawn समेत। तब स्क्रिप्ट मौजूदा attributes फिर से पढ़ती है, इसलिए लेबल कभी पुराना नहीं होता।

क्लाइंट सिर्फ़ पढ़ता है। प्लेयर अपनी स्क्रीन पर जो भी बदले, उसका असली टाइमर पर कोई असर नहीं होता, क्योंकि LocalScript से attributes में बदलाव उसी एक क्लाइंट पर रहते हैं। सेकंड के दसवें हिस्से तक की गिनती के लिए सर्वर इसके बजाय attribute में workspace:GetServerTimeNow() से ख़त्म होने का समय रख सकता है, और हर क्लाइंट हर फ़्रेम उसमें से अपना workspace:GetServerTimeNow() घटाता है।

अगर आपका गेम मेन मेन्यू से खुलता है, तो RoundHud तब दिखता है जब प्लेयर Play दबाता है, क्योंकि StarterGui प्लेयर को उसके कैरेक्टर के स्पॉन होने के बाद ही कॉपी होता है। जो प्लेयर अभी मेन्यू में हैं, उनका कोई कैरेक्टर नहीं होता, इसलिए उन्हें कभी राउंड में टेलीपोर्ट नहीं किया जाता।

राउंड के बीच मरने, निकलने या जॉइन करने वाले प्लेयर

पहली बार राउंड स्क्रिप्ट लिखते समय ये हालात आसानी से छूट जाते हैं। अगर इनमें से कोई संभाला न जाए, तो आमतौर पर आपको Output में एक एरर दिखता है या ऐसा राउंड जो कभी ख़त्म नहीं होता। ऊपर वाली स्क्रिप्ट हर एक के साथ क्या करती है, वह यहाँ है।

मुश्किल हालात और राउंड स्क्रिप्ट उन्हें कैसे संभालती है
हालातक्या होता हैस्क्रिप्ट में कहाँ
प्लेयर राउंड में मरता है (मारा गया, रीसेट किया, गिर गया)उसे राउंड से हटा दिया जाता है, और वह Players.RespawnTime (डिफ़ॉल्ट 5 सेकंड) के बाद लॉबी में respawn होता है।humanoid.Died eliminate को कॉल करता है
कैरेक्टर बिना मरे हटा दिया गयामरने जैसा ही: प्लेयर बाहर।player.CharacterRemoving eliminate को कॉल करता है
प्लेयर सर्वर छोड़ देता हैउसे हटा दिया जाता है, उसके कनेक्शन डिस्कनेक्ट होते हैं, और अगला टिक पक्षों को फिर से गिनता है।Players.PlayerRemoving eliminate को कॉल करता है
प्लेयर राउंड के बीच जॉइन करता हैवह लॉबी में स्पॉन होता है, लाइव स्टेटस और टाइमर देखता है और अगले राउंड में शामिल होता है।भाग लेने वाले सिर्फ़ startRound में चुने जाते हैं
राउंड शुरू होते समय प्लेयर मरा हुआ थाउसे टेलीपोर्ट नहीं किया जाता, वह लॉबी में इंतज़ार करता है।getLivingCharacter
सब निकल गए या मर गएराउंड "Nobody survived" के साथ ख़त्म होता है, और लूप फिर शुरू होता है: Intermission, अगर सर्वर पर अभी भी काफ़ी प्लेयर हैं, वरना Waiting।runRound में sidesLeft == 0

eliminate ऐसे लिखा गया है कि उसे एक ही प्लेयर के लिए कई बार कॉल करना सुरक्षित है। जो प्लेयर मरा और respawn हुआ, वह Died और CharacterRemoving दोनों चलाता है, और जो निकल रहा है वह तीनों इवेंट चला सकता है; असर सिर्फ़ पहली कॉल का होता है।

कैसे बढ़ाएँ: टीमें, मैप वोटिंग और राउंड इवेंट

आख़िरी बची टीम

USE_TEAMS = true करें, फिर Explorer में Teams सर्विस में Team ऑब्जेक्ट जोड़ें, हर एक का अपना नाम और TeamColor। डिफ़ॉल्ट रूप से Roblox हर नए प्लेयर को सबसे कम सदस्यों वाली auto-assignable टीम में डालता है। प्लेयर के निकलने पर वह टीमों को फिर से बैलेंस नहीं करता, इसलिए लंबे सेशन में टीमें असमान हो सकती हैं। लॉबी का SpawnLocation Neutral रहने दें, ताकि सारी टीमें वहीं स्पॉन हों। तब राउंड तब ख़त्म होता है जब ज़िंदा प्लेयर सिर्फ़ एक टीम में बचे हों, और नतीजा "Red wins!" जैसा दिखता है।

"एक बनाम सब" फ़ॉर्मेट (एक शिकारी, बाक़ी बचने वाले) के लिए startRound में एक रैंडम भाग लेने वाला चुनें और टेलीपोर्ट से पहले उसकी Team शिकारी की टीम कर दें। शिकारी की टीम का AutoAssignable बंद करें, ताकि नए प्लेयर कभी उसमें न जाएँ, और cleanup में शिकारी को बचने वालों की टीम में लौटा दें। तब वही ख़त्म होने की शर्तें काम करती हैं: अगर सारे बचने वाले बाहर हो गए तो शिकारी जीतता है, और अगर बचने वाले टाइमर ख़त्म होने तक टिके रहे तो वे जीतते हैं, बशर्ते समय ख़त्म होने पर आप शिकारी का awardWin छोड़ दें।

प्लेयर का मैप के लिए वोट

वोटिंग के लिए क्लाइंट को सर्वर से बात करनी होती है, यानी RemoteEvent चाहिए। इंटरमिशन के दौरान सर्वर attributes से दो या तीन मैप के नाम पब्लिश करता है, हर क्लाइंट RemoteEvent से वह नाम भेजता है जिस पर क्लिक किया, और सर्वर loadMap चलाने से पहले वोट गिनता है। सर्वर को हर वोट जाँचना ज़रूरी है: कि argument एक string है, कि वह मौजूदा विकल्पों में से एक है, कि स्टेट Intermission है और कि हर प्लेयर एक ही बार गिना जाए (वोट Player key वाली टेबल में रखें ताकि दूसरा वोट पहले की जगह ले, और PlayerRemoving में उसे साफ़ करें)। RemoteEvent गाइड जाँच के इस पैटर्न को विस्तार से समझाती है।

राउंड की शुरुआत में टूल देना

दूसरी स्क्रिप्ट RoundSystem को छुए बिना राउंड पर रिएक्ट कर सकती हैं। राउंड स्क्रिप्ट हर प्लेयर को टेलीपोर्ट करते समय InRound attribute सेट करती है, और बाहर होने पर उसे हटा देती है। यह स्क्रिप्ट उसे सुनती है और हर प्लेयर को ServerStorage में रखे RoundTool नाम के Tool की कॉपी देती है।

Script स्थान: ServerScriptService नाम: GiveRoundTool
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local toolTemplate = ServerStorage:WaitForChild("RoundTool") :: Tool

local function watchPlayer(player: Player)
	player:GetAttributeChangedSignal("InRound"):Connect(function()
		if player:GetAttribute("InRound") ~= true then
			return
		end
		local backpack = player:FindFirstChildOfClass("Backpack")
		if backpack then
			toolTemplate:Clone().Parent = backpack
		end
	end)
end

Players.PlayerAdded:Connect(watchPlayer)
for _, player in Players:GetPlayers() do
	watchPlayer(player)
end

टूल वापस लेने वाला कोई कोड नहीं है। जब कैरेक्टर मरता है, Roblox Backpack को StarterPack से भरे नए Backpack से बदल देता है, और सफ़ाई के समय LoadCharacterAsync बचे हुए प्लेयर का Backpack ख़ाली कर देता है, इसलिए राउंड के बाद टूल नहीं रहता।

अगर देने के लिए हथियार चाहिए, तो एक तलवार या raycast वाली गन बनाएँ, उसे StarterPack के बजाय ServerStorage में रखें और इस स्क्रिप्ट में "RoundTool" को उसके नाम से बदल दें।

सिर्फ़ राउंड के समय के लिए NPC और दूसरी चीज़ें

जो कुछ सिर्फ़ राउंड के दौरान होना चाहिए, वह मैप मॉडल के अंदर रह सकता है: दुश्मन, उठाई जाने वाली चीज़ें, चलते प्लेटफ़ॉर्म। ServerStorage में मॉडल के अंदर की स्क्रिप्ट नहीं चलतीं; जैसे ही कॉपी Workspace में आती है, वे चालू हो जाती हैं, और सफ़ाई के समय map:Destroy() उन्हें बाक़ी सब के साथ हटा देता है। प्लेयर का पीछा करने वाले दुश्मन जोड़ने के लिए NPC pathfinding गाइड से एक बनाएँ और उसे मैप में रखें। हर राउंड की शुरुआत में मैप के ऊपर से उड़ान के लिए कटसीन गाइड दिखाती है कि यह स्क्रिप्ट BindableEvent से हर प्लेयर के लिए कटसीन कैसे चला सकती है।

इसे मॉड्यूल कैसे बनाएँ

शुरुआत में ModuleScript की ज़रूरत नहीं है। गेम बनाते समय एक Script पढ़ना आसान है। इसे तब बाँटें जब दूसरी स्क्रिप्ट को राउंड के फ़ंक्शन कॉल करने हों या जब आप सेटिंग्स को एक साझा ModuleScript में ले जाना चाहें, जिसे सर्वर और आपका UI दोनों require से जोड़ सकें। तब तक RoundInfo पर State attribute और हर प्लेयर पर InRound attribute पहले से राउंड सिस्टम के पब्लिक इंटरफ़ेस की तरह काम करते हैं: कोई भी स्क्रिप्ट उन्हें सुन सकती है।

आम गलतियाँ और उनके हल

Play दबाने से पहले Output विंडो खोलें (Studio के Window मेन्यू से या Script टैब से)। राउंड सिस्टम की ज़्यादातर समस्याएँ वहाँ स्क्रिप्ट के नाम और लाइन नंबर के साथ एक चेतावनी या एरर दिखाती हैं।

"Waiting for players (1/2)" पर अटका है

आप अकेले टेस्ट कर रहे हैं, और MIN_PLAYERS 2 है। अकेले टेस्ट के लिए इसे 1 करें या 2 क्लाइंट के साथ Server & Clients मोड में टेस्ट करें।

Infinite yield possible on 'ServerStorage:WaitForChild("Maps")'

फ़ोल्डर नहीं है, उसके नाम में टाइपो है या वह ग़लत सर्विस में है। यह ठीक Maps नाम का Folder होना चाहिए, सीधे ServerStorage के अंदर। LocalScript में RoundInfo के लिए ऐसी ही चेतावनी का मतलब है कि RoundSystem स्क्रिप्ट उसे बनाने तक पहुँची ही नहीं: वह बंद है, एरर से रुक गई या अभी भी Maps फ़ोल्डर का इंतज़ार कर रही है।

टेलीपोर्ट के बाद प्लेयर मैप के आर-पार गिर जाते हैं

मैप के पार्ट Anchored नहीं हैं, इसलिए कॉपी Workspace में आते ही बिखर जाती है। मैप चुनें, उसके पार्ट Anchor करें और देखें कि स्पॉन पार्ट फ़र्श के ऊपर हैं, उसके अंदर नहीं।

बाहर हुए प्लेयर एरीना में respawn होते हैं

मैप के अंदर एक SpawnLocation है। उसे उस मैप के Spawns फ़ोल्डर में एक सामान्य Part से बदल दें।

सबके मरने पर भी राउंड ख़त्म नहीं होता

देखें कि आपका डैमेज सच में Humanoid को मारता है (health 0 तक पहुँचती है), न कि प्लेयर को सिर्फ़ खिसकाता या Anchor करता है। अगर आपने Humanoid की Dead स्टेट बंद कर दी है, तो Died कभी नहीं चलता, और राउंड को टाइमर ख़त्म होने तक चलना पड़ता है।

एक एरर के बाद राउंड लूप हमेशा के लिए रुक जाता है

लूप एक ही thread में चलता है, इसलिए किसी भी स्टेट में एरर उसे ख़त्म कर देता है। Output में एरर पढ़ें, लाइन ठीक करें और फिर से टेस्ट करें। आम वजह: स्क्रिप्ट को ऐसे बदला गया कि वह कैरेक्टर के होने की जाँच किए बिना player.Character.Humanoid इस्तेमाल करती है।

RoCode से बनाएँ

अगर यह सब हाथ से नहीं बनाना चाहते, तो RoCode इसे आपके खुले place में बना सकता है। यह एक AI एजेंट है जो Roblox Studio प्लगइन के ज़रिए काम करता है, इसलिए स्क्रिप्ट और पार्ट आपके Explorer में दिखते हैं, किसी चैट विंडो में नहीं जहाँ से उन्हें पेस्ट करना पड़े।

आप लिखते हैं

राउंड सिस्टम जोड़ो: 20 सेकंड का इंटरमिशन जिसे 2 प्लेयर चाहिए, ServerStorage.Maps से रैंडम मैप, सबको मैप के स्पॉन पार्ट पर टेलीपोर्ट करो, 2 मिनट के राउंड जिनमें आख़िरी ज़िंदा प्लेयर जीते, leaderstats में Win जोड़ो और स्क्रीन के ऊपर स्टेटस और टाइमर दिखाओ।

RoCode करता है
  • पहले List Children, Search Game और Search Scripts से आपका place देख सकता है, ताकि दूसरा सेट जोड़ने के बजाय आपका Maps फ़ोल्डर और leaderstats स्क्रिप्ट इस्तेमाल करे
  • Create Script से ServerScriptService में राउंड Script और टाइमर का LocalScript बनाता है, और अगर आपके पास अभी मैप नहीं है तो Place Prefab से अपने तैयार बिल्ड में से एक एरीना रख सकता है
  • पूरा करने से पहले Studio के अंदर Check Script से हर स्क्रिप्ट का compile जाँचता है। यह syntax की गलतियाँ पकड़ता है, राउंड लॉजिक की गलतियाँ नहीं
  • आपके playtest के बाद Check Output पिछले playtest की Server और Client लाइनें पढ़ता है, ताकि रनटाइम एरर ठीक कर सके

प्लगइन 3.9 या नए के साथ RoCode एक छोटा playtest चलाकर एरर पढ़ सकता है, और प्लगइन 3.9.11 या नए के साथ एक टेस्ट कैरेक्टर चला सकता है, लेकिन यह कई प्लेयर के साथ टेस्ट नहीं करता, इसलिए राउंड ख़ुद Server & Clients मोड में चलाकर देखें। बदलावों का हर समूह Studio में एक undo पॉइंट है। राउंड लूप कई गेम की नींव है, और AI से पूरा Roblox गेम, सिस्टम दर सिस्टम, बनाना अक्सर ऐसे ही लूप से शुरू होता है। RoCode Studio से कैसे जुड़ता है।

अक्सर पूछे जाने वाले सवाल

Roblox में टीमों वाला राउंड सिस्टम कैसे बनाएं?

Teams सर्विस में Team ऑब्जेक्ट जोड़ें और राउंड स्क्रिप्ट में USE_TEAMS = true करें। Roblox नए प्लेयर को सबसे कम सदस्यों वाली auto-assignable टीम में डालता है, और राउंड तब ख़त्म होता है जब ज़िंदा प्लेयर सिर्फ़ एक टीम में बचे हों।

सभी प्लेयर को उलटी गिनती कैसे दिखाएँ?

सर्वर से बचे हुए सेकंड ReplicatedStorage के किसी ऑब्जेक्ट पर attribute के रूप में सेट करें और LocalScript में GetAttributeChangedSignal से उसे सुनें, जो TextLabel अपडेट करती है, जैसे स्टेप 3 में। बाद में आने वाले प्लेयर को तुरंत मौजूदा वैल्यू मिल जाती है।

राउंड लूप में क्या इस्तेमाल करें: wait() या task.wait()?

task.wait() इस्तेमाल करें। Roblox ग्लोबल wait() को deprecated और task.wait() से बदला गया बताता है।

हर राउंड के लिए प्लेयर को दूसरे place में कैसे टेलीपोर्ट करें?

यह दूसरा टूल है। यह गाइड कैरेक्टर को एक ही सर्वर के अंदर PivotTo से ले जाती है। प्लेयर को आपके experience के दूसरे place में भेजना TeleportService से होता है, जो उन्हें दूसरे सर्वर पर ले जाता है। टेलीपोर्ट गाइड ऐसे पोर्टल बनाती है, साथ में टेलीपोर्ट फ़ेल होने पर दोबारा कोशिश।

टेलीपोर्ट के बाद प्लेयर एक पल के लिए क्यों अटक जाते हैं?

instance streaming चालू होने पर क्लाइंट को अभी मैप नहीं मिला। स्क्रिप्ट में "तैयार हो जाइए" वाली गिनती के दौरान RequestStreamAroundAsync कॉल इंजन से उसे पहले भेजने को कहती है; लंबा GET_READY_SECONDS धीमे कनेक्शन को ज़्यादा समय देता है।

स्रोत और आगे पढ़ें

कोड की जाँच कैसे हुई: इस पेज की हर स्क्रिप्ट Roblox API परिभाषाओं के साथ Luau की strict type checking से गुज़रती है (luau-lsp, 20 नवंबर 2026)। Type checking API नामों की गलतियाँ और गलत टाइप पकड़ लेती है, लेकिन गेम लॉजिक की गलतियाँ नहीं, इसलिए पब्लिश करने से पहले सब कुछ Studio में टेस्ट करें।

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

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