チュートリアル · ゲームシステム

Roblox Studio でラウンドシステムを作る方法

Roblox のラウンド制ゲームのほとんどは、同じループを回しています。プレイヤーを待ち、0 までカウントダウンし、マップを読み込み、全員をそこへテレポートし、タイマーを進め、勝者を決めて、片付けます。このガイドでは、このループをわかりやすい1つのサーバースクリプトとして組み立て、すべてのプレイヤーに見えるタイマーを追加し、コピーしたスクリプトが壊れがちなケース、つまりラウンドの途中で死ぬ、抜ける、参加するプレイヤーについて解説します。

更新日 2026年11月20日読了時間 約3分執筆

要点

ServerScriptService に1つのサーバー Script を書き、決まった状態の並びを繰り返し進めます。インターミッション(必要な人数がそろうのを待ってからカウントダウン)、マップの読み込み(ServerStorage のランダムなマップを Workspace に複製)、テレポート(生きているキャラクターをそれぞれ PivotTo でスポーン用パーツへ移動)、ラウンド(時間切れになるか、残りがプレイヤー1人かチーム1つになるまでタイマーを進める)、片付け(Wins を与え、生存者を復活させ、マップを削除)です。

  • ループはサーバーでだけ動かします。状態と残り秒数は ReplicatedStorage の Folder の属性として公開し、表示は LocalScript に任せます。
  • まだラウンドに残っている人の表を持っておきます。Humanoid が死んだとき、キャラクターが削除されたとき、プレイヤーが抜けたときに、そのプレイヤーを表から外します。
  • テレポートするのは、ラウンド開始の瞬間にキャラクターが生きているプレイヤーだけです。あとから来た人は、ロビーで次のラウンドを待ちます。
このページの内容
  1. 仕組み
  2. 1. ロビーとマップ
  3. 2. ラウンドのスクリプト
  4. 状態の仕組み
  5. 3. タイマーの UI
  6. ラウンド途中のプレイヤー
  7. 拡張する
  8. Common errors
  9. RoCode で作る
  10. よくある質問
  11. 参考資料

ラウンドシステムの仕組み

イメージ完成したラウンドのスクリプトを実行中のゲームで動かしたもの(早送り)。

ラウンドシステムはステートマシンです。サーバーはどの瞬間もちょうど1つの状態にあり、それぞれの状態には1つの仕事があり、1つの条件で次の状態に進みます。こう書けばロジックがすべて1か所にまとまり、タイマーのループとラウンドのループの両方が同じラウンドを終わらせようとする、よくあるバグも起きません。

このガイドのラウンドループの状態
状態サーバーがすること次へ進むとき
Waiting"Waiting for players (1/2)" と表示するサーバーに十分な人数がそろった
Intermission全員がロビーにいる間、時間をカウントダウンするカウントダウンが終わった(プレイヤーが抜けたら Waiting に戻る)
Startingランダムなマップを Workspace にコピーし、その名前を表示し、クライアントに読み込みを頼む短い「準備して」のカウントダウンが終わった
InRound生きているプレイヤーをテレポートし、タイマーを進め、死んだ人や抜けた人を外す時間切れ、または残りがプレイヤー1人かチーム1つ
Resultsまだ生きている全員に Win を与え、誰が勝ったかを表示する数秒たった
Cleanup生存者をロビーで復活させ、マップを削除するすぐに。そのあとループが最初から始まる

すべての状態はサーバーが持っています。クライアントはサーバーに言われたことを表示するだけです。LocalScript でのカウントダウンは本物とずれ、あとから来た人には正しくなく、エクスプロイターに書き換えられるおそれもあります。サーバーとクライアントの分け方が初めてなら、先に Script vs LocalScript vs ModuleScript を読んでください。

ステップ1: ロビー、マップ、Wins のステータスを用意する

  1. Workspace に SpawnLocation のあるロビーを作ります。すべてのプレイヤーがここでスポーンし、ここで待ち、脱落後にここへ戻るように、Neutral プロパティにチェックが入っていることを確認します。
  2. ServerStorage に Maps という名前の Folder を挿入します。ServerStorage の中のオブジェクトはプレイヤーに送られないので、使っていないマップがプレイヤーの負担になることはありません。
  3. 各マップを Maps の中の Model として作り、パーツは Anchored にします。マップはロビーから離れた場所に作ります(数百スタッドあれば十分です)。コピーは作った場所にそのまま現れますし、脱落したプレイヤーが歩いて戻れてはいけないからです。
  4. 各マップの中に Spawns という名前の Folder を追加し、その中に想定するプレイヤー1人につき1つ、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 を作るスクリプトが2つあると、各プレイヤーにフォルダーが2つできてしまいます。

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人でテストする間は 1 にします
local INTERMISSION_SECONDS = 20
local GET_READY_SECONDS = 5
local ROUND_SECONDS = 120
local RESULTS_SECONDS = 5
local USE_TEAMS = false -- true: プレイヤーが1つのチームにしか残っていないとラウンドが終わります

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

-- 各プレイヤーの画面に出す内容は、このフォルダーの属性に入れておきます。
-- サーバーが設定した属性は、あとから参加した人も含めてすべてのクライアントに複製されます。
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 が床からどれだけ上にあるか。
-- Roblox の Humanoid.HipHeight のリファレンスにある式です(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

	-- ストリーミングが有効なら、キャラクターが着く前にマップを読み込むよう各クライアントに頼みます
	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。時間切れになるか、陣営が1つだけ残ったら終わります。
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()
		-- 1つの陣営で始まったラウンド(1人でのテスト)は、時間切れか死亡でしか終わりません
		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

-- ループ: 1周が1ラウンドです
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 の3つの属性(State、Status、TimeLeft)と、各プレイヤーの InRound 属性だけです。

それぞれの状態の仕組み

待機とインターミッション

runIntermission は、まず #Players:GetPlayers() が MIN_PLAYERS に届くまでループを止めておきます。それから task.wait(1) で1秒ずつカウントダウンし、1回ごとに人数を確認します。誰かが抜けてサーバーの人数が最低人数を下回ると false を返し、メインのループは Waiting からやり直すので、1人だけでラウンドが始まることはありません。

マップの選択と読み込み

loadMap は ServerStorage.Maps の中の Model をすべて集め、選択肢があれば前回のラウンドのマップを外し、Random:NextInteger で1つ選びます。それからマップを Workspace に複製します。元のマップは ServerStorage に手つかずのまま残るので、毎ラウンド新しいコピーから始まります。前のラウンドでプレイヤーが壊したり動かしたりしたものは、すべて消えます。

新しいプレイスではインスタンスのストリーミングが有効になっていて、クライアントは自分のキャラクターの近くにあるパーツしか持っていません。テレポートの前に、スクリプトは各プレイヤーに対して Player:RequestStreamAroundAsync を呼び出します。これで「準備して」のカウントダウンの間に、マップのまわりの範囲をクライアントに送るようエンジンに頼みます。これがないと、床が読み込まれる前にプレイヤーが到着して、一瞬固まってしまうことがあります。

PivotTo でプレイヤーをテレポートする

カウントダウンのあと、スクリプトは参加者のリストを作ります。対象は、キャラクターが存在し、まだワールドの中にあり、体力が 0 より大きい 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 は1秒に1回進みます。1回ごとに状態の表示(残りのプレイヤー数)と残り秒数を更新し、生きている陣営を数えます。ラウンドは次の3つのどれかで終わります:

  • 時間切れ。for ループが 1 まで進んで終わります。
  • 陣営が1つだけ残った。陣営とはプレイヤー、または USE_TEAMS が有効ならチームのことです。この判定はラウンドが2つ以上の陣営で始まったときだけ働くので、1人でのテストが始まった瞬間に終わることはありません。
  • 誰も残っていない。全員が死んだか抜けて、勝者なしでラウンドが終わります。

1秒に1回の判定なので、最後の脱落からラウンドが終わるまで最大1秒かかることがありますが、ラウンドのタイマーではほとんど気になりません。

Wins の付与と結果の表示

このスクリプトのルールはシンプルで、ラウンド終了の時点で生きている全員が勝ちです。これで、最後に生き残ったプレイヤー、最後に生き残ったチーム、「タイマーが切れるまで耐えろ」のモードが、1行のロジックですべてまかなえます。finishRound は勝者それぞれの Wins に 1 を足し、見張りをやめて、"Alex wins!" のようなメッセージを RESULTS_SECONDS の間表示します。時間切れのときは勝者なしにしたいなら、sidesLeft が 1 より大きいときに awardWin を飛ばしてメッセージを変えてください。どちらの場合も、リストは返し続けてください。片付けはこのリストを使って生存者をロビーに戻すからです。

片付け

生存者はまだマップの上に立っているので、cleanup は古い LoadCharacter に代わる Player:LoadCharacterAsync() で彼らをロビーで復活させ、それからマップのコピーを削除します。復活はそれぞれ pcall の中の別々の task.spawn で行います。この呼び出しはキャラクターの読み込みを待つので、ちょうどそのときにプレイヤーが抜けると失敗することがあるからです。脱落したプレイヤーには何もする必要はありません。すでに自分でロビーに復活しています。

ステップ3: タイマーと状態をすべてのプレイヤーに表示する

サーバーは ReplicatedStorage.RoundInfo に3つの属性を公開します。State(スクリプト向けの、InRound のような決まった単語)、Status(人向けのテキスト)、TimeLeft(秒数)です。サーバーのスクリプトが複製されるオブジェクトに設定した属性は、自動ですべてのクライアントに届き、ラウンドの途中で参加したプレイヤーもすぐに今の値を受け取ります。だからタイマーにはリモートよりこちらが向いています。誰かが参加する前に送られた 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 -- 長いメッセージは2行目に折り返します
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 の新しいコピーを渡します。そのときスクリプトが今の属性を読み直すので、表示が古くなることはありません。

クライアントは読むだけです。LocalScript から属性を変えても、その変更はそのクライアントの中にとどまるので、プレイヤーが自分の画面で何を変えても本物のタイマーには影響しません。0.1 秒単位のカウントダウンにしたいなら、サーバーが代わりに workspace:GetServerTimeNow() による終了時刻を属性に入れ、各クライアントが毎フレーム、そこから自分の workspace:GetServerTimeNow() を引く方法もあります。

ゲームがメインメニューから始まる場合、StarterGui はキャラクターがスポーンしてからプレイヤーにコピーされるので、RoundHud はプレイヤーが Play を押したときに表示されます。まだメニューにいるプレイヤーにはキャラクターがないので、ラウンドにテレポートされることはありません。

ラウンドの途中で死ぬ、抜ける、参加するプレイヤー

初めてラウンドのスクリプトを書くとき、これらのケースは見落としがちです。どれかを処理していないと、たいてい Output にエラーが出るか、いつまでも終わらないラウンドになります。上のスクリプトがそれぞれのケースで何をするかを示します。

例外的なケースと、ラウンドのスクリプトの対処
状況起きることスクリプトの場所
プレイヤーがラウンド中に死ぬ(倒された、リセットした、落ちた)ラウンドから外され、Players.RespawnTime(初期値は5秒)のあとにロビーで復活します。humanoid.Died が eliminate を呼ぶ
死なずにキャラクターが削除される死んだときと同じで、そのプレイヤーは脱落です。player.CharacterRemoving が eliminate を呼ぶ
プレイヤーがサーバーから抜ける外されて接続が切られ、次の1秒で陣営が数え直されます。Players.PlayerRemoving が eliminate を呼ぶ
プレイヤーがラウンドの途中で参加するロビーでスポーンし、進行中の状態とタイマーを見て、次のラウンドに参加します。参加者は startRound でだけ選ばれる
ラウンド開始の瞬間に死んでいたテレポートされず、ロビーで待ちます。getLivingCharacter
全員が抜けたか死んだラウンドは "Nobody survived" で終わり、ループが最初から始まります。サーバーにまだ十分な人数がいれば Intermission、いなければ Waiting です。runRound の sidesLeft == 0

eliminate は、同じプレイヤーに何度呼んでも安全なように書いてあります。死んで復活したプレイヤーは Died と CharacterRemoving の両方を起こしますし、抜けるプレイヤーは3つのイベントすべてを起こすことがありますが、何かをするのは最初の呼び出しだけです。

拡張する:チーム、マップ投票、ラウンドのイベント

最後に生き残ったチーム

USE_TEAMS = true にしてから、Explorer の Teams サービスに Team オブジェクトを追加し、それぞれに名前と TeamColor を付けます。初期設定では、Roblox は参加したプレイヤーを、自動で割り当てるチームのうちいちばん人数の少ないチームに入れます。プレイヤーが抜けてもチームの組み直しはしないので、長いセッションではチームの人数が偏ることがあります。すべてのチームがロビーでスポーンするように、ロビーの SpawnLocation は Neutral のままにしておきます。これで、生きているプレイヤーが1つのチームにしか残っていないときにラウンドが終わり、結果は "Red wins!" のように表示されます。

「1人対全員」の形式(鬼が1人、残りは生き残る側)にするなら、startRound で参加者からランダムに1人選び、テレポートの前にその人の Team を鬼のチームにします。鬼のチームの AutoAssignable はオフにして、新しいプレイヤーが入らないようにし、cleanup で鬼を生き残る側のチームに戻します。こうすれば同じ終了条件がそのまま使えます。生き残る側が全員脱落すれば鬼の勝ち、タイマーが切れるまで耐えれば生き残る側の勝ちです。ただし、時間切れのときは鬼の awardWin を飛ばしてください。

プレイヤーによるマップ投票

投票では、クライアントがサーバーとやりとりする必要があるので、RemoteEvent が必要です。インターミッションの間、サーバーは2つか3つのマップ名を属性で公開し、各クライアントは押したマップ名を RemoteEvent で送り、サーバーは loadMap を実行する前に票を数えます。サーバーはすべての票を確認しなければなりません。引数が文字列であること、今の選択肢のどれかであること、状態が Intermission であること、各プレイヤーが1回だけ数えられることです(票は Player をキーにした表に入れて、2回目の票が1回目を置き換えるようにし、PlayerRemoving で消します)。この確認の型は RemoteEvent のガイドで詳しく説明しています。

ラウンド開始時にツールを渡す

ほかのスクリプトは、RoundSystem に手を加えずにラウンドに反応できます。ラウンドのスクリプトは、プレイヤーをテレポートするときに InRound 属性を設定し、脱落したときに外します。このスクリプトはその属性を聞いて、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 から作った新しいものに入れ替え、片付けでの LoadCharacterAsync が生存者の Backpack を空にするので、ラウンドのあとにはツールはもうありません。

配る武器が必要なら、剣やレイキャストの銃を作り、StarterPack ではなく ServerStorage に置いて、このスクリプトの "RoundTool" をその名前に変えてください。

ラウンドの間だけの NPC やほかのオブジェクト

ラウンドの間だけ存在すべきものは、敵、拾えるアイテム、動く足場など、すべてマップのモデルの中に入れておけます。ServerStorage にあるモデルの中のスクリプトは動きませんが、コピーが Workspace に置かれると動き出し、片付けの map:Destroy() がほかのものと一緒に削除します。プレイヤーを追いかける敵を追加するなら、NPC の pathfinding のガイドで1体作ってマップに入れましょう。各ラウンドの始めにマップを見渡すカメラ演出をしたいなら、カットシーンのガイドに、このスクリプトから BindableEvent で各プレイヤーにカットシーンを流す方法があります。

これをモジュールにするには

最初は ModuleScript はいりません。ゲームを作っている間は、1つの Script のほうが読みやすいです。ほかのスクリプトからラウンドの関数を呼び出す必要が出てきたときや、サーバーと UI の両方が require できる共通の ModuleScript に設定をまとめたいときに分割しましょう。それまでは、RoundInfo の State 属性と各プレイヤーの InRound 属性が、すでにラウンドシステムの公開インターフェースとして働いています。どのスクリプトでもこれらを聞くことができます。

よくあるエラーと対処法

Play を押す前に Output ウィンドウを開いておきます(Studio の Window メニューか Script タブから)。ラウンドシステムの問題のほとんどは、そこにスクリプト名と行番号付きの警告やエラーを出します。

"Waiting for players (1/2)" で止まる

1人でテストしていて、MIN_PLAYERS が 2 になっています。1人でのテストでは 1 にするか、Server & Clients モードでクライアントを 2 にしてテストしてください。

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

フォルダーがないか、名前のつづりが違うか、別のサービスに入っています。ServerStorage の直下にある、名前がちょうど Maps の Folder でなければなりません。LocalScript で RoundInfo について同じ警告が出る場合は、RoundSystem のスクリプトがそれを作るところまで進んでいません。スクリプトが無効になっているか、エラーで止まったか、まだ Maps フォルダーを待っています。

テレポートしたあと、プレイヤーがマップをすり抜けて落ちる

マップのパーツが Anchored になっていないので、コピーが Workspace に置かれたとたんにバラバラになります。マップを選んでパーツを Anchored にし、スポーン用パーツが床の中ではなく床の上にあることを確認してください。

脱落したプレイヤーがアリーナで復活する

マップの中に SpawnLocation があります。そのマップの Spawns フォルダーにある普通の Part に置き換えてください。

全員が死んでもラウンドが終わらない

ダメージが本当に Humanoid を倒している(体力が 0 になる)か、プレイヤーを動かしたり固定したりしているだけでないかを確認してください。Humanoid の Dead の状態を無効にしていると Died が発火しないので、ラウンドはタイマーが切れるまで続くしかありません。

1回エラーが出たら、ラウンドのループが完全に止まった

ループは1つのスレッドで動いているので、どの状態でエラーが起きてもループは終わります。Output のエラーを読んでその行を直し、もう一度テストしてください。よくある原因は、キャラクターが存在するかを確認せずに player.Character.Humanoid を使うようにスクリプトを変えたことです。

RoCode で作る

これを全部手で組み立てたくない場合は、RoCode があなたの開いているプレイスで作れます。RoCode は Roblox Studio のプラグインを通して動く AI エージェントなので、スクリプトやパーツは、貼り付けが必要なチャット画面ではなく、あなたの Explorer に現れます。

あなたの入力

ラウンドシステムを追加して。2人必要な20秒のインターミッション、ServerStorage.Maps からランダムなマップ、全員をマップのスポーン用パーツへテレポート、最後に生き残ったプレイヤーが勝つ2分のラウンド、leaderstats に Win を追加して、状態とタイマーを画面の上に表示して。

RoCode の作業
  • まず List Children、Search Game、Search Scripts であなたのプレイスを見て、2つ目を足すのではなく、あなたの Maps フォルダーと leaderstats のスクリプトを使えます
  • Create Script で ServerScriptService にラウンドの Script を、タイマーの LocalScript を作り、まだマップがなければ Place Prefab で完成済みの建物からアリーナを置けます
  • 終える前に Check Script で各スクリプトが Studio の中でコンパイルできるかを確認します。見つかるのは文法のエラーで、ラウンドのロジックの誤りではありません
  • あなたがプレイテストしたあと、Check Output が直前のプレイテストの Server と Client の行を読み、実行時のエラーを直します

プラグイン 3.9 以降の RoCode は短いプレイテストを実行してエラーを読め、プラグイン 3.9.11 以降ではテスト用のキャラクターを1体動かせますが、複数プレイヤーでのテストはしないので、ラウンドは自分で Server & Clients モードで試してください。変更のまとまりごとに Studio の取り消しポイントになります。ラウンドのループは多くのゲームの土台で、AI で Roblox のゲームを仕組みごとに丸ごと作るときも、こうしたループから始めることがよくあります。RoCode が Studio につながる仕組み。

よくある質問

Roblox でチーム制のラウンドシステムを作るには?

Teams サービスに Team オブジェクトを追加し、ラウンドのスクリプトで USE_TEAMS = true にします。Roblox は参加したプレイヤーを、自動で割り当てるチームのうちいちばん人数の少ないチームに振り分け、生きているプレイヤーが1つのチームにしか残っていないときにラウンドが終わります。

カウントダウンを全プレイヤーに表示するには?

ステップ3のように、サーバーから残り秒数を ReplicatedStorage のオブジェクトの属性として設定し、TextLabel を更新する LocalScript で GetAttributeChangedSignal を使ってそれを聞きます。あとから参加したプレイヤーもすぐに今の値を受け取ります。

ラウンドのループには wait() と task.wait() のどちらを使えばいいですか?

task.wait() を使ってください。Roblox はグローバルの wait() を非推奨とし、task.wait() に置き換えられたものとしています。

ラウンドごとにプレイヤーを別のプレイスにテレポートするには?

それは別の道具です。このガイドは PivotTo で同じサーバーの中でキャラクターを動かします。experience の別のプレイスにプレイヤーを送るには TeleportService を使い、プレイヤーは別のサーバーに移ります。テレポートのガイドで、テレポートが失敗したときの再試行付きで、それを行うポータルを作っています。

テレポートしたあと、プレイヤーが一瞬固まるのはなぜですか?

インスタンスのストリーミングが有効で、クライアントがまだマップを受け取っていないからです。スクリプトで「準備して」のカウントダウン中に RequestStreamAroundAsync を呼ぶと、先に送るようエンジンに頼めます。GET_READY_SECONDS を長くすると、遅い回線の人に時間の余裕ができます。

参考資料

コードの検証方法: このページのスクリプトはすべて、Roblox API の型定義(luau-lsp、2026年11月20日)を使った Luau の strict 型チェックを通っています。型チェックで見つかるのは API 名の誤りや型の不一致であり、ゲームロジックの誤りは見つかりません。公開する前に必ず Studio でテストしてください。

RoCode を自分のゲームで試してみましょう。

毎日無料のクレジット付き、カード不要です。プラグインを入れて、作りたい機能を説明し、Studio に反映された内容を確認してください。