Eğitim · Oyun sistemleri

Roblox Studio'da round sistemi nasıl yapılır

Roblox'taki round tabanlı oyunların çoğu aynı döngüyü çalıştırır: oyuncuları bekler, sıfıra kadar sayar, haritayı yükler, herkesi oraya ışınlar, zamanlayıcıyı işletir, kazananı seçer ve ortalığı toplar. Bu rehberde bu döngüyü tek, anlaşılır bir sunucu scripti olarak kuruyoruz, her oyuncunun gördüğü bir zamanlayıcı ekliyoruz ve kopyalanan scriptlerin bozulduğu durumları ele alıyoruz: round ortasında ölen, çıkan ya da giren oyuncular.

Güncellendi: 20 Kasım 202612 dk okumaYazan:

Kısaca

ServerScriptService'e tek bir sunucu Script'i yaz ve sabit bir durum dizisinden sırayla geçsin: intermission (yeterli oyuncuyu bekle, sonra geri sayım), harita yükleme (ServerStorage'dan rastgele bir haritayı Workspace'e klonla), ışınlanma (yaşayan her karakteri PivotTo ile bir spawn part'ına taşı), round (süre bitene ya da tek oyuncu veya tek takım kalana kadar zamanlayıcıyı işlet) ve temizlik (Wins ver, hayatta kalanları yeniden doğur, haritayı sil).

  • Döngüyü sadece sunucuda çalıştır. Durumu ve kalan saniyeleri ReplicatedStorage'daki bir Folder üzerinde attribute olarak yayınla, göstermeyi bir LocalScript yapsın.
  • Hâlâ roundda olanların bir tablosunu tut. Bir oyuncunun Humanoid'i öldüğünde, karakteri silindiğinde ya da oyundan çıktığında onu tablodan çıkar.
  • Sadece round başladığı anda karakteri yaşayan oyuncuları ışınla. Sonradan girenler bir sonrakini lobide bekler.
Bu sayfada
  1. Nasıl çalışır
  2. 1. Lobi ve haritalar
  3. 2. Round scripti
  4. Durumlar nasıl çalışır
  5. 3. Zamanlayıcı UI'ı
  6. Round ortasındaki oyuncular
  7. Nasıl genişletilir
  8. Common errors
  9. RoCode ile
  10. Sık sorulan sorular
  11. Kaynaklar ve ek okumalar

Round sistemi nasıl çalışır

ÇizimHazır round scriptleri çalışan bir oyunda, hızlandırılmış.

Bir round sistemi bir durum makinesidir. Sunucu her an tam olarak tek bir durumdadır, her durumun tek bir işi vardır ve tek bir koşul onu bir sonrakine geçirir. Böyle yazınca bütün mantık tek bir yerde durur ve zamanlayıcı döngüsüyle round döngüsünün aynı roundu bitirmeye çalıştığı klasik hata ortaya çıkmaz.

Bu rehberdeki round döngüsünün durumları
DurumSunucu ne yaparNe zaman sonrakine geçer
Waiting"Waiting for players (1/2)" gösterirSunucuda yeterli oyuncu var
IntermissionHerkes lobideyken süreyi geri sayarGeri sayım bitti (ya da oyuncular çıktıysa Waiting'e geri döner)
StartingRastgele bir haritayı Workspace'e kopyalar, adını gösterir, istemcilerden onu yüklemelerini isterKısa "hazırlan" geri sayımı bitti
InRoundYaşayan oyuncuları ışınlar, zamanlayıcıyı işletir, ölen ya da çıkanları çıkarırSüre bitti ya da tek oyuncu veya tek takım kaldı
ResultsHâlâ yaşayan herkese bir Win verir ve kimin kazandığını gösterirBirkaç saniye geçti
CleanupHayatta kalanları lobide yeniden doğurur ve haritayı silerHemen, ardından döngü baştan başlar

Her durumun sahibi sunucudur. İstemciler sadece sunucunun söylediğini gösterir. Bir LocalScript'teki geri sayım gerçeğinden kayar, sonradan girenlerde yanlış olur ve bir hileci onu değiştirebilir. Sunucu ve istemci ayrımı senin için yeniyse önce Script vs LocalScript vs ModuleScript yazısını oku.

Adım 1: Lobiyi, haritaları ve Wins istatistiğini kur

  1. Workspace'te bir SpawnLocation ile bir lobi inşa et. Neutral özelliğinin işaretli olduğunu kontrol et, böylece her oyuncu burada doğar, burada bekler ve elendikten sonra buraya döner.
  2. ServerStorage'a Maps adlı bir Folder ekle. ServerStorage'daki nesneler oyunculara asla gönderilmez, yani kullanılmayan haritalar onlara hiçbir şeye mal olmaz.
  3. Her haritayı Maps içinde, part'ları anchored olan bir Model olarak kur. Onu lobiden uzağa inşa et (birkaç yüz stud yeterli), çünkü kopya tam olarak inşa ettiğin yerde belirir ve elenen oyuncular tekrar içeri yürüyememeli.
  4. Her haritanın içine Spawns adlı bir Folder ekle, içine de beklenen her oyuncu için bir anchored Part koy. Onlara Transparency 1 ver ve CanCollide'ı kapat, böylece kimse onları görmez ve onlara takılmaz.
Bu rehberden sonra 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

Round scripti oyuncunun leaderstats klasöründeki Wins adlı IntValue'ya 1 ekler. Oyununda henüz leaderstats yoksa bu kısa scripti ekle. Zaten varsa, örneğin lider tablosu rehberindeki kaydeden sürüm, bunu atla: leaderstats oluşturan iki script her oyuncuya iki klasör verir.

Script konum: ServerScriptService adı: Leaderstats
local Players = game:GetService("Players")

local function setupLeaderstats(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- ad tam olarak bu olmalı, küçük harflerle

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

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(setupLeaderstats)

-- Studio'da bu script çalışmadan önce girmiş olabilirsin, o yüzden zaten burada olan herkesi kuruyoruz
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Bu Wins oyuncu çıkınca sıfırlanır. Oturumlar arasında kalması için lider tablosu rehberindeki DataStore'lu sürümü kullan.

Adım 2: Round scriptini ekle

ServerScriptService'e bir Script ekle, adını RoundSystem koy ve aşağıdaki kodu yapıştır. Üstteki ayarlar büyük ihtimalle değiştirmen gereken tek satırlar. Her durum ayrı bir fonksiyon ve en alttaki döngü onları sırayla, sonsuza kadar çalıştırır.

Script konum: ServerScriptService adı: RoundSystem
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerStorage = game:GetService("ServerStorage")

-- Ayarlar
local MIN_PLAYERS = 2 -- tek başına test ederken 1 yap
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: oyuncular sadece tek bir takımda kaldığında round biter

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

-- Her oyuncunun ekranının gösterdiği şey bu klasördeki attribute'larda tutulur.
-- Sunucunun ayarladığı attribute'lar, sonradan girenler dahil tüm istemcilere replike olur.
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

-- Mevcut roundda hâlâ kim var ve her birini izleyen bağlantılar
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)

-- Karakteri ve Humanoid'i sadece oyuncu şu anda yaşıyorsa döndürür
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

-- Roundda kalan tarafları sayar (oyuncular ya da USE_TEAMS açıksa takımlar)
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

-- DURUM: Waiting ve Intermission. Geri sayım sırasında oyuncular çıktıysa false döndürür.
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

-- DURUM: Starting, 1. kısım. Rastgele bir harita kopyalıyoruz (seçenek varsa öncekini değil).
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
	-- Karıştırıyoruz, böylece oyuncular her round aynı spawn'a düşmez
	for i = #points, 2, -1 do
		local j = random:NextInteger(1, i)
		points[i], points[j] = points[j], points[i]
	end
	return points
end

-- Ayakta duran bir karakterin root part'ı zeminden ne kadar yüksekte.
-- Formül Roblox'un Humanoid.HipHeight başvurusundan (R6 rig'lerde bacak yüksekliği eklenir).
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

-- DURUM: Starting, 2. kısım. Hazırlan, sonra yaşayan herkesi ışınla.
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 açıksa her istemciden karakter gelmeden önce haritayı yüklemesini istiyoruz
	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

	-- Sadece şu anda yaşayanlar katılır. Diğerleri bir sonraki roundu bekler.
	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]
			-- Karakterin pivot'u root part'ıdır, bu yüzden onu part'ın üstünde ayakta durma yüksekliğine kaldırıyoruz
			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

-- DURUM: InRound. Süre bittiğinde ya da tek taraf kaldığında biter.
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()
		-- Tek tarafla başlayan bir round (tek başına test) sadece süreyle ya da ölümle biter
		if sidesLeft == 0 or (startingSides > 1 and sidesLeft == 1) then
			break
		end
	end
end

-- DURUM: Results. Hâlâ yaşayan herkes kazanır.
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) -- onları izlemeyi bırakıyoruz; temizliğe kadar haritada kalırlar
	end
	setState("Results", message)
	task.wait(RESULTS_SECONDS)
	return winners
end

-- DURUM: Cleanup. Hayatta kalanları lobiye geri gönderiyoruz, sonra haritayı siliyoruz.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- hâlâ sunucuda
			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

-- Döngü: bir tur bir round demek
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) -- henüz harita yok: birazdan tekrar deneriz
		end
	end
end

Önemli olan her şey burada, sunucuda olur: roundda kim var, zamanlayıcı, kazanan ve Wins. İstemciler sadece ReplicatedStorage.RoundInfo üzerindeki üç attribute'u (State, Status ve TimeLeft) ve her oyuncunun üzerindeki InRound attribute'unu alır.

Her durum nasıl çalışır

Bekleme ve intermission

runIntermission önce #Players:GetPlayers() MIN_PLAYERS'a ulaşana kadar döngüyü tutar. Sonra task.wait(1) ile saniye saniye geri sayar ve her tikte oyuncu sayısını kontrol eder. Biri çıkıp sunucu minimumun altına düşerse false döndürür ve ana döngü Waiting'den baştan başlar, yani round asla tek kişiyle başlamaz.

Haritayı seçmek ve yüklemek

loadMap, ServerStorage.Maps içindeki tüm Model'leri toplar, seçenek varsa önceki roundun haritasını çıkarır ve Random:NextInteger ile birini seçer. Sonra haritayı Workspace'e klonlar. Orijinali ServerStorage'da dokunulmadan kalır, yani her round taze bir kopyayla başlar: oyuncuların önceki roundda kırdığı ya da yerinden oynattığı her şey kaybolur.

Yeni place'lerde instance streaming açıktır: istemcide sadece karakterinin yakınındaki part'lar bulunur. Script ışınlamadan önce her oyuncu için Player:RequestStreamAroundAsync'i çağırır; bu, motordan "hazırlan" geri sayımı sırasında haritanın etrafındaki alanı istemciye göndermesini ister. Bu olmadan oyuncular zemin yüklenmeden önce varabilir ve bir anlığına donabilir.

Oyuncuları PivotTo ile ışınlamak

Geri sayımdan sonra script, karakteri var olan, hâlâ dünyada duran ve canı 0'dan büyük bir Humanoid'i ile root part'ı olan oyunculardan bir katılımcı listesi toplar. Bu kontrol geri sayımdan sonra yapılır, yani geri sayım sırasında ölen ya da çıkan kişi listeye girmez.

Her katılımcı character:PivotTo(cframe) ile taşınır. Roblox başvurusu PivotTo'yu modelleri scriptten taşımanın ana yolu olarak gösterir ve karakterin tüm parçalarını birlikte taşır. HumanoidRootPart.Position'ı ayarlamak aynı şey değil: Roblox bağlantıları öyle ayarlar ki sadece o parça hareket eder ve vücudun geri kalanı geride kalabilir. Karakterin pivot'u root part'ıdır, bu yüzden hedef, part'ın yüksekliğinin yarısı artı root part'ın zeminden yüksekliği kadar kaldırılmış spawn part CFrame'idir. rootHeight bunu Roblox'un Humanoid.HipHeight başvurusundaki formülle hesaplar: root part yüksekliğinin yarısı artı HipHeight, R6 rig'lerde artı bacak uzunluğu. Böylece ölçeklenmiş ve özel avatarlar part'ın içine sıkışmaz ve üstüne düşmez. CFrame dönüşü de içerir, yani oyuncular spawn part'ının baktığı yöne bakar: part'ları herkes haritanın ortasına bakacak şekilde döndür.

Oyuncu sayısı spawn part'larından fazlaysa script ilk part'tan yeniden başlar ve oyuncular üst üste biner, bu yüzden en az maksimum oyuncu sayın kadar spawn ekle.

Koşma rehberindeki hız kontrolünü de kullanıyorsan, ışınlanmanın hız aşımı sayılmaması için startRound içinde character:PivotTo(...)'dan hemen sonra player:SetAttribute("MovementCheckSkip", true) ekle.

Round zamanlayıcısı ve bitiş koşulları

runRound saniyede bir tikler. Her tikte durumu (kaç oyuncu kaldı) ve kalan saniyeleri günceller, sonra yaşayan tarafları sayar. Round üç şekilde biter:

  • Süre bitti. for döngüsü 1'e ulaşır ve sona erer.
  • Tek taraf kaldı. Taraf bir oyuncu ya da USE_TEAMS açıksa bir takımdır. Kontrol sadece round iki ya da daha fazla tarafla başladıysa çalışır, yani tek başına test başladığı anda bitmez.
  • Kimse kalmadı. Herkes öldü ya da çıktı ve round kazanansız biter.

Saniyede bir kontrol, roundun son elenmeden sonra bir saniyeye kadar daha sürebileceği anlamına gelir; bir round zamanlayıcısında bu neredeyse fark edilmez.

Wins vermek ve sonucu göstermek

Bu scriptteki kural basit: round bittiği anda yaşayan herkes kazanır. Bu tek mantık satırı hem son hayatta kalan oyuncuyu, hem son hayatta kalan takımı, hem de "zamanlayıcı bitene kadar dayan" modunu kapsar. finishRound her kazananın Wins'ine 1 ekler, onları izlemeyi bırakır ve RESULTS_SECONDS boyunca "Alex wins!" gibi bir mesaj gösterir. Süre bittiğinde kazanan olmasın istiyorsan, sidesLeft 1'den büyükken awardWin'i atla ve mesajı değiştir. Her durumda listeyi döndürmeye devam et, çünkü temizlik hayatta kalanları ona göre lobiye geri getirir.

Temizlik

Hayatta kalanlar hâlâ haritada duruyor, bu yüzden cleanup onları eski LoadCharacter'ın yerini alan Player:LoadCharacterAsync() ile lobide yeniden doğurur, sonra harita kopyasını siler. Her yeniden doğuş bir pcall içinde kendi task.spawn'ında çalışır, çünkü çağrı karakterin yüklenmesini bekler ve oyuncu tam o anda çıkıyorsa hata verebilir. Elenen oyuncular için bir şey gerekmez: zaten kendiliğinden lobide yeniden doğdular.

Adım 3: Zamanlayıcıyı ve durumu her oyuncuya göster

Sunucu ReplicatedStorage.RoundInfo üzerinde üç attribute yayınlar: State (scriptler için InRound gibi sabit bir kelime), Status (insanlar için metin) ve TimeLeft (saniye). Bir sunucu scriptinin replike olan bir nesneye ayarladığı attribute'lar otomatik olarak her istemciye ulaşır ve round ortasında giren bir oyuncu mevcut değerleri hemen alır. Bu yüzden zamanlayıcı için bu bir remote'tan daha uygun: biri girmeden önce gönderilen bir RemoteEvent ona asla ulaşmaz.

  1. Explorer'da StarterGui'ye bir ScreenGui ekle ve adını RoundHud koy. ResetOnSpawn'ı açık bırak (varsayılan).
  2. RoundHud'a bir LocalScript ekle, adını RoundHudClient koy ve aşağıdaki kodu yapıştır. Yazıyı kendisi oluşturur, yani başka bir şey çizmen gerekmez.
  3. Play'e bas. Ekranın üstündeki yazı durumu ve m:ss biçiminde geri sayımı gösterir.
LocalScript konum: StarterGui içindeki RoundHud ScreenGui'si adı: RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- Yazı. RoundHud'da kendi TextLabel'ını çizdiysen bu bloğu sil ve şunu kullan:
-- 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 -- uzun mesajlar ikinci satıra geçer
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 açık olduğu için Roblox, temizlikteki yeniden doğuş dahil karakter her doğduğunda oyuncuya RoundHud'un taze bir kopyasını verir. Script o zaman mevcut attribute'ları yeniden okur, yani yazı asla eskimez.

İstemci sadece okur. Oyuncunun kendi ekranında değiştirdiği hiçbir şey gerçek zamanlayıcıyı etkilemez, çünkü bir LocalScript'ten yapılan attribute değişiklikleri o tek istemcide kalır. Saniyenin onda biri hassasiyetinde bir geri sayım için sunucu bunun yerine attribute'ta workspace:GetServerTimeNow()'dan bir bitiş zamanı tutabilir, her istemci de her karede kendi workspace:GetServerTimeNow()'unu ondan çıkarır.

Oyunun bir ana menüyle açılıyorsa RoundHud oyuncu Play'e bastığında görünür, çünkü StarterGui oyuncuya ancak karakteri doğduktan sonra kopyalanır. Hâlâ menüde olan oyuncuların karakteri yoktur, bu yüzden asla rounda ışınlanmazlar.

Round ortasında ölen, çıkan ya da giren oyuncular

Bir round scriptini ilk kez yazarken bu durumları atlamak kolay. Biri ele alınmamışsa genelde Output'ta bir hata ya da hiç bitmeyen bir round görürsün. Yukarıdaki script her biriyle şunu yapar.

Uç durumlar ve round scriptinin onlarla nasıl başa çıktığı
DurumNe olurScriptte nerede
Oyuncu roundda ölür (öldürüldü, reset attı, düştü)Rounddan çıkarılır ve Players.RespawnTime (varsayılan 5 saniye) sonra lobide yeniden doğar.humanoid.Died, eliminate'i çağırır
Karakter ölmeden silinirÖlümdeki gibi: oyuncu elendi.player.CharacterRemoving, eliminate'i çağırır
Oyuncu sunucudan çıkarÇıkarılır, bağlantıları kesilir ve bir sonraki tik tarafları yeniden sayar.Players.PlayerRemoving, eliminate'i çağırır
Oyuncu round ortasında girerLobide doğar, canlı durumu ve zamanlayıcıyı görür ve bir sonraki rounda katılır.Katılımcılar sadece startRound'da seçilir
Oyuncu round başladığında ölüydüIşınlanmaz, lobide bekler.getLivingCharacter
Herkes çıktı ya da öldüRound "Nobody survived" ile biter ve döngü baştan başlar: sunucuda hâlâ yeterli oyuncu varsa Intermission, yoksa Waiting.runRound içinde sidesLeft == 0

eliminate aynı oyuncu için birkaç kez çağrılması güvenli olacak şekilde yazıldı. Ölüp yeniden doğan bir oyuncu hem Died'ı hem CharacterRemoving'i tetikler, çıkan biri de üç event'in hepsini tetikleyebilir; bir şey yapan sadece ilk çağrıdır.

Nasıl genişletilir: takımlar, harita oylaması ve round event'leri

Son hayatta kalan takım

USE_TEAMS = true yap, sonra Explorer'da Teams servisine Team nesneleri ekle, her birine kendi adını ve TeamColor'ını ver. Varsayılan olarak Roblox giren her oyuncuyu en az üyeli otomatik atanan takıma koyar. Oyuncular çıktığında takımları yeniden dengelemez, yani uzun oturumlarda takımlar eşitsiz hale gelebilir. Lobideki SpawnLocation'ı Neutral bırak ki tüm takımlar orada doğsun. O zaman round yaşayan oyuncular sadece tek bir takımda kaldığında biter ve sonuç "Red wins!" gibi görünür.

"Bire karşı herkes" formatı için (bir avcı, geri kalanlar hayatta kalmaya çalışır) startRound'da rastgele bir katılımcı seç ve ışınlamadan önce onun Team'ini avcı takımı yap. Avcı takımında AutoAssignable'ı kapat ki yeni oyuncular oraya hiç düşmesin ve cleanup'ta avcıyı hayatta kalanlar takımına geri koy. Böylece aynı bitiş koşulları çalışır: tüm hayatta kalanlar elenirse avcı kazanır, zamanlayıcının sonuna kadar dayanırlarsa hayatta kalanlar kazanır, yeter ki süre bittiğinde avcının awardWin'ini atla.

Oyuncuların harita oylaması

Oylama için istemcinin sunucuyla konuşması gerekir, yani bir RemoteEvent lazım. Intermission sırasında sunucu iki ya da üç harita adını attribute olarak yayınlar, her istemci tıkladığı adı RemoteEvent ile gönderir ve sunucu loadMap'i çalıştırmadan önce oyları sayar. Sunucu her oyu kontrol etmek zorunda: argümanın bir string olduğunu, mevcut seçeneklerden biri olduğunu, durumun Intermission olduğunu ve her oyuncunun bir kez sayıldığını (oyları anahtarı Player olan bir tabloda tut ki ikinci oy ilkinin yerini alsın ve onu PlayerRemoving'de temizle). RemoteEvent rehberi bu kontrol kalıbını ayrıntılı anlatıyor.

Round başında tool vermek

Diğer scriptler RoundSystem'a dokunmadan rounda tepki verebilir. Round scripti her oyuncuyu ışınladığında ona InRound attribute'unu koyar ve oyuncu elendiğinde kaldırır. Bu script onu dinler ve her oyuncuya ServerStorage'da duran RoundTool adlı Tool'un bir kopyasını verir.

Script konum: ServerScriptService adı: 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

Tool'u geri alan bir kod yok. Karakter öldüğünde Roblox Backpack'i StarterPack'ten doldurulmuş tazesiyle değiştirir, temizlikteki LoadCharacterAsync de hayatta kalanlarınkini boşaltır, yani rounddan sonra tool artık yoktur.

Verilecek bir silah lazımsa bir kılıç ya da raycast'li bir silah yap, onu StarterPack yerine ServerStorage'da tut ve bu scriptteki "RoundTool"'u onun adıyla değiştir.

Sadece round süresince var olan NPC'ler ve diğer nesneler

Sadece round sırasında var olması gereken her şey harita modelinin içinde yaşayabilir: düşmanlar, toplanabilir eşyalar, hareketli platformlar. ServerStorage'daki bir modelin içindeki scriptler çalışmaz; kopya Workspace'e girdiği anda çalışmaya başlarlar ve temizlikteki map:Destroy() onları her şeyle birlikte siler. Oyuncuları kovalayan düşmanlar eklemek için NPC pathfinding rehberine göre bir tane yap ve haritaya koy. Her round başında haritanın üstünden uçan bir çekim için cutscene rehberi bu scriptin bir BindableEvent ile her oyuncuya nasıl cutscene başlatabileceğini gösteriyor.

Bundan nasıl modül yapılır

Başlangıçta bir ModuleScript gerekmez. Oyunu kurarken tek bir Script'i okumak daha kolay. Diğer scriptlerin round fonksiyonlarını çağırması gerektiğinde ya da ayarları hem sunucunun hem UI'ının require ile alabileceği ortak tek bir ModuleScript'e taşımak istediğinde onu böl. O zamana kadar RoundInfo üzerindeki State attribute'u ve her oyuncunun üzerindeki InRound attribute'u zaten round sisteminin açık arayüzü gibi çalışıyor: her script onları dinleyebilir.

Sık yapılan hatalar ve çözümleri

Play'e basmadan önce Output penceresini (Studio'daki Window menüsünden ya da Script sekmesinden) aç. Round sistemi sorunlarının çoğu orada script adı ve satır numarasıyla bir uyarı ya da hata yazdırır.

"Waiting for players (1/2)"'de takılıyor

Tek başına test ediyorsun ve MIN_PLAYERS 2. Tek kişilik testler için 1 yap ya da 2 istemciyle Server & Clients modunda test et.

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

Klasör yok, adında yazım hatası var ya da yanlış serviste. Doğrudan ServerStorage içinde, adı tam olarak Maps olan bir Folder olmalı. LocalScript'te RoundInfo için aynı uyarı, RoundSystem scriptinin onu oluşturmaya hiç gelemediği anlamına gelir: kapalı, hatayla durdu ya da hâlâ Maps klasörünü bekliyor.

Işınlandıktan sonra oyuncular haritadan aşağı düşüyor

Haritanın part'ları anchored değil, bu yüzden kopya Workspace'e girdiği anda dağılıyor. Haritayı seç, part'larını anchor'la ve spawn part'larının zeminin içinde değil üstünde durduğunu kontrol et.

Elenen oyuncular arenada yeniden doğuyor

Haritanın içinde bir SpawnLocation var. Onu o haritanın Spawns klasöründe normal bir Part ile değiştir.

Herkes öldüğünde round bitmiyor

Hasarının Humanoid'i gerçekten öldürdüğünü (can 0'a iniyor) ve oyuncuları sadece hareket ettirmediğini ya da anchor'lamadığını kontrol et. Humanoid'in Dead durumunu kapattıysan Died hiç tetiklenmez ve round zamanlayıcının sonuna kadar sürmek zorunda kalır.

Round döngüsü tek bir hatadan sonra tamamen duruyor

Döngü tek bir thread'de çalışır, yani herhangi bir durumdaki hata onu bitirir. Output'taki hatayı oku, satırı düzelt ve tekrar test et. Sık bir sebep: script, karakterin var olup olmadığını kontrol etmeden player.Character.Humanoid'i kullanacak şekilde değiştirilmiş.

RoCode ile yap

Bunların hepsini elle kurmak istemiyorsan RoCode bunu açık olan place'inde yapabilir. Roblox Studio plugin'i üzerinden çalışan bir yapay zeka ajanı, bu yüzden scriptler ve part'lar yapıştırman gereken bir sohbet penceresinde değil, Explorer'ında belirir.

Sen yazarsın

Bir round sistemi ekle: 2 oyuncu gerektiren 20 saniyelik bir intermission, ServerStorage.Maps'ten rastgele bir harita, herkesi haritanın spawn part'larına ışınla, son yaşayan oyuncunun kazandığı 2 dakikalık roundlar, leaderstats'a bir Win ekle ve ekranın üstünde durumu ve zamanlayıcıyı göster.

RoCode yapar
  • İkinci bir set eklemek yerine senin Maps klasörünü ve leaderstats scriptini kullanmak için önce place'ini List Children, Search Game ve Search Scripts ile inceleyebilir
  • Round Script'ini ServerScriptService'te ve zamanlayıcı LocalScript'ini Create Script ile oluşturur; henüz haritan yoksa Place Prefab ile hazır yapılarından bir arena koyabilir
  • Bitirmeden önce her scriptin derlendiğini Studio içinde Check Script ile kontrol eder. Bu, round mantığı hatalarını değil, sözdizimi hatalarını yakalar
  • Senin oyun testinden sonra Check Output, çalışma sırasındaki bir hatayı düzeltmek için son oyun testinin Server ve Client satırlarını okur

Plugin 3.9 ya da üstüyle RoCode kısa bir oyun testi yapıp hataları okuyabilir, plugin 3.9.11 ya da üstüyle de tek bir test karakterini yönetebilir, ama birden fazla oyuncuyla test etmez; bu yüzden roundları Server & Clients modunda kendin dene. Her değişiklik grubu Studio'da bir geri alma noktasıdır. Round döngüsü birçok oyunun temelinde yatar ve yapay zeka ile bütün bir Roblox oyununu sistem sistem yapmak çoğu zaman böyle bir döngüyle başlar. RoCode Studio'ya nasıl bağlanır.

Sık sorulan sorular

Roblox'ta takımlı bir round sistemi nasıl yapılır?

Teams servisine Team nesneleri ekle ve round scriptinde USE_TEAMS = true yap. Roblox giren oyuncuları en az üyeli otomatik atanan takıma dağıtır ve round, yaşayan oyuncular sadece tek bir takımda kaldığında biter.

Geri sayımı tüm oyunculara nasıl gösteririm?

Kalan saniyeleri sunucudan ReplicatedStorage'daki bir nesnede attribute olarak ayarla ve 3. adımdaki gibi bir TextLabel'ı güncelleyen bir LocalScript'te GetAttributeChangedSignal ile dinle. Sonradan giren oyuncular mevcut değeri hemen alır.

Round döngüsünde ne kullanmalıyım: wait() mi task.wait() mi?

task.wait() kullan. Roblox global wait()'i eskimiş ve yerini task.wait()'in aldığı olarak işaretliyor.

Her round için oyuncuları başka bir place'e nasıl ışınlarım?

Bu farklı bir araç. Bu rehber karakterleri tek bir sunucu içinde PivotTo ile taşıyor. Oyuncuları experience'ının başka bir place'ine göndermek TeleportService ile olur ve onları başka bir sunucuya taşır. Teleport rehberi bunu yapan portalları, ışınlanma başarısız olursa tekrar denemeyle birlikte kuruyor.

Oyuncular ışınlandıktan sonra neden bir anlığına donuyor?

Instance streaming açıkken istemci haritayı henüz almamıştır. Scriptteki "hazırlan" geri sayımı sırasında yapılan RequestStreamAroundAsync çağrısı motordan onu önceden göndermesini ister; daha uzun bir GET_READY_SECONDS yavaş bağlantılara daha fazla zaman verir.

Kaynaklar ve ek okumalar

Kod nasıl kontrol edildi: bu sayfadaki her script, Roblox API tanımlarıyla Luau'nun katı tür denetleyicisinden geçiyor (luau-lsp, 20 Kasım 2026). Tür denetimi yanlış yazılmış API'leri ve hatalı türleri yakalar, oyun mantığını değil. Bu yüzden yayınlamadan önce Studio'da test et.

RoCode'u kendi oyununda dene.

Her gün ücretsiz kredi, kart gerekmez. Plugin'i kur, özelliği anlat ve Studio'da ne oluştuğunu kontrol et.