บทเรียน · ระบบเกม

วิธีทำระบบรอบเกมใน Roblox Studio

เกมแบบรอบส่วนใหญ่ใน Roblox หมุนลูปเดียวกัน: รอผู้เล่น นับถอยหลัง โหลดแผนที่ เทเลพอร์ตทุกคนไปที่นั่น เดินตัวจับเวลา เลือกผู้ชนะ และเก็บกวาด ในคู่มือนี้เราสร้างลูปนี้เป็นสคริปต์ฝั่งเซิร์ฟเวอร์ตัวเดียวที่อ่านเข้าใจง่าย เพิ่มตัวจับเวลาที่ผู้เล่นทุกคนเห็น และอธิบายกรณีที่ทำให้สคริปต์ที่ก๊อปมาพัง: ผู้เล่นที่ตาย ออก หรือเข้ามากลางรอบ

อัปเดตเมื่อ 20 พฤศจิกายน 2569อ่าน 4 นาทีเขียนโดย

สรุปสั้น ๆ

เขียน Script ฝั่งเซิร์ฟเวอร์ตัวเดียวใน ServerScriptService ที่วนผ่านชุดสถานะตายตัว: ช่วงพัก (รอให้ผู้เล่นครบจำนวน แล้วนับถอยหลัง) โหลดแผนที่ (โคลนแผนที่สุ่มจาก ServerStorage ไปยัง Workspace) เทเลพอร์ต (ย้ายตัวละครที่ยังมีชีวิตทุกตัวไปยังพาร์ตจุดเกิดด้วย PivotTo) รอบเกม (เดินตัวจับเวลาจนหมดเวลา หรือเหลือผู้เล่นหรือทีมเดียว) และเก็บกวาด (ให้ Wins ให้ผู้รอดเกิดใหม่ ลบแผนที่)

  • รันลูปบนเซิร์ฟเวอร์เท่านั้น ประกาศสถานะและวินาทีที่เหลือเป็นแอตทริบิวต์บน Folder ใน ReplicatedStorage แล้วให้ LocalScript เป็นตัวแสดง
  • เก็บตารางของคนที่ยังอยู่ในรอบ เอาผู้เล่นออกเมื่อ Humanoid ของเขาตาย ตัวละครถูกลบ หรือเขาออกจากเกม
  • เทเลพอร์ตเฉพาะผู้เล่นที่ตัวละครยังมีชีวิตตอนเริ่มรอบ คนที่เข้ามาทีหลังรอในล็อบบี้สำหรับรอบถัดไป
ในหน้านี้
  1. วิธีการทำงาน
  2. 1. ล็อบบี้และแผนที่
  3. 2. สคริปต์รอบเกม
  4. สถานะทำงานอย่างไร
  5. 3. UI ตัวจับเวลา
  6. ผู้เล่นกลางรอบ
  7. วิธีต่อยอด
  8. Common errors
  9. ด้วย RoCode
  10. คำถามที่พบบ่อย
  11. แหล่งข้อมูลและบทความแนะนำ

ระบบรอบเกมทำงานอย่างไร

ภาพประกอบสคริปต์รอบเกมที่เสร็จแล้วในเกมที่กำลังรัน แบบเร่งความเร็ว

ระบบรอบเกมคือเครื่องสถานะ (state machine) ในทุกขณะ เซิร์ฟเวอร์อยู่ในสถานะเดียวพอดี แต่ละสถานะมีงานเดียว และมีเงื่อนไขเดียวที่พามันไปสถานะถัดไป ถ้าเขียนแบบนี้ ตรรกะทั้งหมดจะอยู่ในที่เดียว และจะไม่เกิดบั๊กคลาสสิกที่ลูปตัวจับเวลากับลูปรอบเกมต่างพยายามจบรอบเดียวกัน

สถานะของลูปรอบเกมในคู่มือนี้
สถานะเซิร์ฟเวอร์ทำอะไรไปต่อเมื่อไร
Waitingแสดง "Waiting for players (1/2)"มีผู้เล่นบนเซิร์ฟเวอร์พอแล้ว
Intermissionนับถอยหลังขณะที่ทุกคนอยู่ในล็อบบี้นับถอยหลังจบ (หรือกลับไป Waiting ถ้าผู้เล่นออกไป)
Startingก๊อปแผนที่สุ่มไปยัง Workspace แสดงชื่อแผนที่ ขอให้ไคลเอนต์โหลดมันการนับถอยหลังสั้น ๆ "เตรียมพร้อม" จบ
InRoundเทเลพอร์ตผู้เล่นที่ยังมีชีวิต เดินตัวจับเวลา เอาคนที่ตายหรือออกไปออกหมดเวลา หรือเหลือผู้เล่นหรือทีมเดียว
Resultsให้ Win กับทุกคนที่ยังมีชีวิต และแสดงว่าใครชนะผ่านไปไม่กี่วินาที
Cleanupให้ผู้รอดเกิดใหม่ในล็อบบี้และลบแผนที่ทันที แล้วลูปเริ่มใหม่

เซิร์ฟเวอร์เป็นเจ้าของทุกสถานะ ไคลเอนต์แค่แสดงสิ่งที่เซิร์ฟเวอร์บอก การนับถอยหลังใน LocalScript จะคลาดจากของจริง ผิดสำหรับคนที่เข้ามาทีหลัง และผู้ใช้โปรโกงแก้ได้ ถ้าการแบ่งฝั่งเซิร์ฟเวอร์กับไคลเอนต์เป็นเรื่องใหม่สำหรับคุณ อ่าน Script vs LocalScript vs ModuleScript ก่อน

ขั้นตอนที่ 1: สร้างล็อบบี้ แผนที่ และสถิติ Wins

  1. สร้างล็อบบี้ใน Workspace ที่มี SpawnLocation ตรวจว่าติ๊กพร็อพเพอร์ตี Neutral ไว้ เพื่อให้ผู้เล่นทุกคนเกิดที่นี่ รอที่นี่ และกลับมาที่นี่หลังตกรอบ
  2. ใน ServerStorage ใส่ Folder ชื่อ Maps อ็อบเจกต์ใน ServerStorage ไม่ถูกส่งให้ผู้เล่นเลย แผนที่ที่ไม่ได้ใช้จึงไม่มีต้นทุนกับพวกเขา
  3. สร้างแต่ละแผนที่เป็น Model ข้างใน Maps โดยพาร์ตต้องAnchored สร้างให้ห่างจากล็อบบี้ (ไม่กี่ร้อยสตัดก็พอ) เพราะสำเนาจะปรากฏตรงที่คุณสร้างไว้พอดี และผู้เล่นที่ตกรอบไม่ควรเดินกลับเข้าไปได้
  4. ข้างในแต่ละแผนที่ เพิ่ม Folder ชื่อ Spawns และใส่ Part ที่ Anchored หนึ่งชิ้นต่อผู้เล่นที่คาดว่าจะมี ตั้ง 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

สคริปต์รอบเกมบวก 1 ให้ IntValue ชื่อ Wins ในโฟลเดอร์ leaderstats ของผู้เล่น ถ้าเกมของคุณยังไม่มี 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: เพิ่มสคริปต์รอบเกม

ใส่ Script ใน ServerScriptService ตั้งชื่อว่า 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()

-- สิ่งที่หน้าจอของผู้เล่นแต่ละคนแสดง เก็บเป็นแอตทริบิวต์บนโฟลเดอร์นี้
-- แอตทริบิวต์ที่เซิร์ฟเวอร์ตั้งจะ 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 (rig แบบ 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 (State, Status และ TimeLeft) และแอตทริบิวต์ InRound บนผู้เล่นแต่ละคน

แต่ละสถานะทำงานอย่างไร

การรอและช่วงพัก

runIntermission ถือลูปไว้ก่อนจนกว่า #Players:GetPlayers() จะถึง MIN_PLAYERS จากนั้นนับถอยหลังทีละวินาทีด้วย task.wait(1) และตรวจจำนวนผู้เล่นทุกครั้ง ถ้ามีคนออกและบนเซิร์ฟเวอร์เหลือน้อยกว่าขั้นต่ำ มันคืนค่า false และลูปหลักเริ่มใหม่จาก Waiting รอบจึงไม่มีวันเริ่มด้วยคนเดียว

เลือกและโหลดแผนที่

loadMap รวบรวม Model ทั้งหมดใน ServerStorage.Maps ตัดแผนที่ของรอบก่อนออกถ้ามีให้เลือก แล้วเลือกหนึ่งอันด้วย Random:NextInteger จากนั้นโคลนแผนที่ลงใน Workspace ต้นฉบับยังอยู่ครบใน ServerStorage ทุกรอบจึงเริ่มด้วยสำเนาใหม่: ทุกอย่างที่ผู้เล่นทำพังหรือขยับในรอบก่อนจะหายไป

place ใหม่เปิด instance streaming ไว้: ไคลเอนต์มีแค่พาร์ตใกล้ตัวละครของมัน ก่อนเทเลพอร์ต สคริปต์เรียก Player:RequestStreamAroundAsync ให้ผู้เล่นแต่ละคน ซึ่งขอให้เอนจินส่งพื้นที่รอบแผนที่ไปให้ไคลเอนต์ระหว่างนับถอยหลัง "เตรียมพร้อม" ถ้าไม่ทำ ผู้เล่นอาจไปถึงก่อนที่พื้นจะโหลด และชะงักไปชั่วครู่

เทเลพอร์ตผู้เล่นด้วย PivotTo

หลังนับถอยหลัง สคริปต์รวบรวมรายชื่อผู้เข้าร่วมจากผู้เล่นที่ตัวละครมีอยู่ ยังอยู่ในโลก และมี Humanoid ที่พลังชีวิตมากกว่า 0 และมี root part การตรวจนี้เกิดหลังการนับถอยหลัง คนที่ตายหรือออกระหว่างนั้นจึงไม่อยู่ในรายชื่อ

ผู้เข้าร่วมแต่ละคนถูกย้ายด้วย character:PivotTo(cframe) เอกสารอ้างอิงของ Roblox เรียก PivotTo ว่าวิธีหลักในการขยับโมเดลจากสคริปต์ และมันขยับทุกส่วนของตัวละครไปด้วยกัน การตั้ง HumanoidRootPart.Position ไม่เหมือนกัน: Roblox ปรับข้อต่อจนขยับแค่ส่วนนั้น และร่างกายที่เหลืออาจค้างอยู่ pivot ของตัวละครคือ root part เป้าหมายจึงเป็น CFrame ของพาร์ตจุดเกิดที่ยกขึ้นครึ่งหนึ่งของความสูงพาร์ต บวกความสูงที่ root part ยืนอยู่เหนือพื้น rootHeight คำนวณตามสูตรในเอกสารอ้างอิง Humanoid.HipHeight ของ Roblox: ครึ่งหนึ่งของความสูง root part บวก HipHeight บวกความยาวขาสำหรับ rig แบบ R6 อวาตาร์ที่ปรับขนาดหรือแบบกำหนดเองจึงไม่ติดในพาร์ตหรือตกลงมาจากด้านบน CFrame รวมการหมุนด้วย ผู้เล่นจึงหันไปทางเดียวกับพาร์ตจุดเกิด: หมุนพาร์ตให้ทุกคนหันเข้าหากลางแผนที่

ถ้าผู้เล่นมากกว่าพาร์ตจุดเกิด สคริปต์จะเริ่มจากพาร์ตแรกใหม่ และผู้เล่นจะซ้อนกัน จึงควรเพิ่มจุดเกิดให้ไม่น้อยกว่าจำนวนผู้เล่นสูงสุด

ถ้าคุณใช้การตรวจความเร็วจากคู่มือการวิ่งเร็วด้วย ให้เพิ่ม player:SetAttribute("MovementCheckSkip", true) ทันทีหลัง character:PivotTo(...) ใน startRound เพื่อไม่ให้การเทเลพอร์ตถูกนับว่าเร็วเกิน

ตัวจับเวลารอบและเงื่อนไขการจบ

runRound เดินวินาทีละครั้ง แต่ละครั้งมันอัปเดตสถานะ (เหลือผู้เล่นกี่คน) และวินาทีที่เหลือ แล้วนับฝ่ายที่ยังมีชีวิต รอบจบได้สามแบบ:

  • หมดเวลา ลูป for ไปถึง 1 แล้วจบ
  • เหลือฝ่ายเดียว ฝ่ายคือผู้เล่น หรือทีมถ้าเปิด USE_TEAMS การตรวจนี้ทำงานเฉพาะเมื่อรอบเริ่มด้วยสองฝ่ายขึ้นไป การทดสอบคนเดียวจึงไม่จบทันทีที่เริ่ม
  • ไม่เหลือใคร ทุกคนตายหรือออก และรอบจบโดยไม่มีผู้ชนะ

การตรวจวินาทีละครั้งหมายความว่ารอบอาจเดินต่ออีกไม่เกินหนึ่งวินาทีหลังการตกรอบครั้งสุดท้าย ซึ่งแทบสังเกตไม่ได้บนตัวจับเวลารอบ

ให้ Wins และแสดงผล

กฎในสคริปต์นี้ง่าย: ทุกคนที่ยังมีชีวิตตอนรอบจบเป็นผู้ชนะ นี่ครอบคลุมทั้งผู้เล่นคนสุดท้ายที่รอด ทีมสุดท้ายที่รอด และโหมด "อยู่รอดจนหมดเวลา" ด้วยตรรกะบรรทัดเดียว finishRound บวก 1 ให้ Wins ของผู้ชนะแต่ละคน เลิกคอยดูพวกเขา และแสดงข้อความอย่าง "Alex wins!" เป็นเวลา RESULTS_SECONDS ถ้าคุณอยากให้ไม่มีผู้ชนะเมื่อหมดเวลา ให้ข้าม awardWin และเปลี่ยนข้อความเมื่อ sidesLeft มากกว่า 1 ไม่ว่าแบบไหน ให้คืนรายชื่อต่อไป เพราะการเก็บกวาดใช้มันส่งผู้รอดกลับล็อบบี้

การเก็บกวาด

ผู้รอดยังยืนอยู่บนแผนที่ cleanup จึงให้พวกเขาเกิดใหม่ในล็อบบี้ด้วย Player:LoadCharacterAsync() ซึ่งแทน LoadCharacter แบบเก่า แล้วลบสำเนาแผนที่ การเกิดใหม่แต่ละครั้งอยู่ใน task.spawn ของตัวเองภายใน pcall เพราะการเรียกนี้รอให้ตัวละครโหลด และอาจล้มเหลวถ้าผู้เล่นกำลังออกพอดี ผู้เล่นที่ตกรอบไม่ต้องทำอะไร: พวกเขาเกิดใหม่ในล็อบบี้เองแล้ว

ขั้นตอนที่ 3: แสดงตัวจับเวลาและสถานะให้ผู้เล่นทุกคน

เซิร์ฟเวอร์ประกาศแอตทริบิวต์สามตัวบน ReplicatedStorage.RoundInfo: State (คำตายตัวอย่าง InRound สำหรับสคริปต์) Status (ข้อความสำหรับคน) และ TimeLeft (วินาที) แอตทริบิวต์ที่สคริปต์ฝั่งเซิร์ฟเวอร์ตั้งบนอ็อบเจกต์ที่ replicate จะไปถึงไคลเอนต์ทุกเครื่องเอง และผู้เล่นที่เข้ามากลางรอบได้ค่าปัจจุบันทันที สำหรับตัวจับเวลาจึงเหมาะกว่า remote: RemoteEvent ที่ส่งไปก่อนที่ใครจะเข้ามา ไม่มีวันไปถึงเขา

  1. ใน Explorer ใส่ ScreenGui ใน StarterGui ตั้งชื่อว่า RoundHud เปิด ResetOnSpawn ไว้ (ค่าเริ่มต้น)
  2. ใส่ LocalScript ใน RoundHud ตั้งชื่อว่า RoundHudClient แล้ววางโค้ดด้านล่าง มันสร้างป้ายข้อความเอง จึงไม่ต้องวาดอะไรเพิ่ม
  3. กด Play ป้ายด้านบนของจอแสดงสถานะและการนับถอยหลังในรูปแบบ m:ss
LocalScript ใน ScreenGui RoundHud ใน StarterGui ชื่อ RoundHudClient
local ReplicatedStorage = game:GetService("ReplicatedStorage")

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

-- ป้ายข้อความ ถ้าคุณวาด TextLabel ของตัวเองใน RoundHud ไว้แล้ว ให้ลบบล็อกนี้และใช้:
-- 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 ใหม่กับผู้เล่นทุกครั้งที่ตัวละครเกิด รวมถึงการเกิดใหม่ตอนเก็บกวาด สคริปต์จึงอ่านแอตทริบิวต์ปัจจุบันใหม่ ป้ายจึงไม่ล้าสมัย

ไคลเอนต์อ่านอย่างเดียว ไม่มีอะไรที่ผู้เล่นเปลี่ยนบนจอของตัวเองมีผลกับตัวจับเวลาจริง เพราะการเปลี่ยนแอตทริบิวต์จาก LocalScript อยู่แค่บนไคลเอนต์นั้น ถ้าจะนับถอยหลังละเอียดถึงหนึ่งในสิบวินาที เซิร์ฟเวอร์อาจเก็บเวลาจบจาก workspace:GetServerTimeNow() ไว้ในแอตทริบิวต์แทน และไคลเอนต์แต่ละเครื่องลบ workspace:GetServerTimeNow() ของตัวเองออกทุกเฟรม

ถ้าเกมของคุณเปิดด้วยเมนูหลัก RoundHud จะปรากฏเมื่อผู้เล่นกด Play เพราะ StarterGui ถูกก๊อปให้ผู้เล่นหลังตัวละครเกิดเท่านั้น ผู้เล่นที่ยังอยู่ในเมนูไม่มีตัวละคร จึงไม่เคยถูกเทเลพอร์ตเข้ารอบ

ผู้เล่นที่ตาย ออก หรือเข้ามากลางรอบ

กรณีเหล่านี้มองข้ามง่ายเมื่อเขียนสคริปต์รอบเกมครั้งแรก ถ้ามีกรณีไหนไม่ได้จัดการ ปกติคุณจะเห็นข้อผิดพลาดใน Output หรือรอบที่ไม่มีวันจบ นี่คือสิ่งที่สคริปต์ด้านบนทำกับแต่ละกรณี

กรณีขอบและวิธีที่สคริปต์รอบเกมจัดการ
สถานการณ์สิ่งที่เกิดขึ้นอยู่ตรงไหนในสคริปต์
ผู้เล่นตายในรอบ (ถูกฆ่า รีเซ็ต ตก)เขาถูกเอาออกจากรอบ และเกิดใหม่ในล็อบบี้หลัง Players.RespawnTime (ค่าเริ่มต้น 5 วินาที)humanoid.Died เรียก eliminate
ตัวละครถูกลบโดยไม่ตายเหมือนตาย: ผู้เล่นตกรอบplayer.CharacterRemoving เรียก eliminate
ผู้เล่นออกจากเซิร์ฟเวอร์เขาถูกเอาออก การเชื่อมต่อของเขาถูกตัด และรอบถัดไปจะนับฝ่ายใหม่Players.PlayerRemoving เรียก eliminate
ผู้เล่นเข้ามากลางรอบเขาเกิดในล็อบบี้ เห็นสถานะและตัวจับเวลาสด ๆ และได้เข้ารอบถัดไปเลือกผู้เข้าร่วมเฉพาะใน startRound
ผู้เล่นตายอยู่ตอนรอบเริ่มเขาไม่ถูกเทเลพอร์ต และรอในล็อบบี้getLivingCharacter
ทุกคนออกหรือตายรอบจบด้วย "Nobody survived" และลูปเริ่มใหม่: Intermission ถ้าบนเซิร์ฟเวอร์ยังมีผู้เล่นพอ ไม่อย่างนั้นเป็น WaitingsidesLeft == 0 ใน runRound

eliminate เขียนให้เรียกซ้ำกับผู้เล่นคนเดียวกันได้อย่างปลอดภัย ผู้เล่นที่ตายแล้วเกิดใหม่เรียกทั้ง Died และ CharacterRemoving และคนที่ออกอาจเรียกครบทั้งสามอีเวนต์ มีแค่การเรียกครั้งแรกที่ทำอะไร

วิธีต่อยอด: ทีม โหวตแผนที่ และอีเวนต์ของรอบ

ทีมสุดท้ายที่รอด

ตั้ง USE_TEAMS = true แล้วเพิ่มอ็อบเจกต์ Team ในเซอร์วิส Teams ใน Explorer แต่ละทีมมีชื่อและ TeamColor ของตัวเอง โดยค่าเริ่มต้น Roblox จัดผู้เล่นทุกคนที่เข้ามาเข้าทีมที่จัดอัตโนมัติได้ซึ่งมีสมาชิกน้อยที่สุด เมื่อผู้เล่นออก มันไม่ปรับสมดุลทีมใหม่ ในเซสชันยาว ๆ ทีมจึงอาจไม่เท่ากัน ให้ SpawnLocation ในล็อบบี้เป็น Neutral เพื่อให้ทุกทีมเกิดที่นั่น จากนั้นรอบจะจบเมื่อผู้เล่นที่ยังมีชีวิตเหลืออยู่ในทีมเดียว และผลลัพธ์จะเป็นแบบ "Red wins!"

สำหรับรูปแบบ "หนึ่งต่อทุกคน" (นักล่าหนึ่งคน คนอื่นเอาตัวรอด) ให้เลือกผู้เข้าร่วมสุ่มหนึ่งคนใน startRound และตั้ง Team ของทีมนักล่าให้เขาก่อนเทเลพอร์ต เอาเครื่องหมายถูกที่ AutoAssignable ของทีมนักล่าออก เพื่อไม่ให้ผู้เล่นใหม่เข้าไปเลย และใน cleanup ให้ย้ายนักล่ากลับไปทีมผู้รอด จากนั้นเงื่อนไขการจบเดิมก็ใช้ได้: นักล่าชนะถ้าผู้รอดตกรอบหมด และผู้รอดชนะถ้าอยู่รอดจนหมดเวลา โดยคุณต้องข้าม awardWin ของนักล่าเมื่อหมดเวลา

ให้ผู้เล่นโหวตแผนที่

การโหวตต้องให้ไคลเอนต์คุยกับเซิร์ฟเวอร์ จึงต้องใช้ RemoteEvent ระหว่างช่วงพัก เซิร์ฟเวอร์ประกาศชื่อแผนที่สองหรือสามชื่อเป็นแอตทริบิวต์ ไคลเอนต์แต่ละเครื่องส่งชื่อที่กดผ่าน RemoteEvent และเซิร์ฟเวอร์นับคะแนนก่อนรัน loadMap เซิร์ฟเวอร์ต้องตรวจทุกคะแนน: อาร์กิวเมนต์เป็นสตริง เป็นหนึ่งในตัวเลือกปัจจุบัน สถานะเป็น Intermission และนับผู้เล่นแต่ละคนครั้งเดียว (เก็บคะแนนในตารางที่มี Player เป็นคีย์ เพื่อให้คะแนนที่สองแทนคะแนนแรก และล้างมันใน PlayerRemoving) คู่มือ RemoteEventอธิบายรูปแบบการตรวจนี้อย่างละเอียด

ให้เครื่องมือตอนเริ่มรอบ

สคริปต์อื่นตอบสนองต่อรอบได้โดยไม่ต้องแตะ RoundSystem สคริปต์รอบเกมตั้งแอตทริบิวต์ InRound ให้ผู้เล่นแต่ละคนเมื่อเทเลพอร์ต และเอาออกเมื่อผู้เล่นตกรอบ สคริปต์นี้ฟังมัน และให้ผู้เล่นแต่ละคนได้สำเนาของ Tool ชื่อ RoundTool ที่อยู่ใน ServerStorage

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 ตอนเก็บกวาดก็ล้างมันให้ผู้รอด หลังรอบจึงไม่มีเครื่องมือเหลือ

ถ้าต้องการอาวุธไว้แจก ให้สร้างดาบหรือปืนแบบ raycast เก็บไว้ใน ServerStorage แทน StarterPack แล้วเปลี่ยน "RoundTool" ในสคริปต์นี้เป็นชื่อของมัน

NPC และอ็อบเจกต์อื่นที่มีแค่ระหว่างรอบ

ทุกอย่างที่ควรมีแค่ระหว่างรอบอยู่ในโมเดลแผนที่ได้: ศัตรู ไอเทมที่เก็บได้ แพลตฟอร์มเคลื่อนที่ สคริปต์ในโมเดลที่อยู่ใน ServerStorage ไม่ทำงาน เมื่อสำเนาอยู่ใน Workspace มันจะเริ่มทำงาน และ map:Destroy() ตอนเก็บกวาดลบมันไปพร้อมทุกอย่าง ถ้าจะเพิ่มศัตรูที่ไล่ผู้เล่น ให้สร้างหนึ่งตัวตามคู่มือ pathfinding ของ NPC แล้วใส่ไว้ในแผนที่ สำหรับการบินผ่านแผนที่ตอนเริ่มแต่ละรอบ คู่มือคัตซีนแสดงว่าสคริปต์นี้เริ่มคัตซีนให้ผู้เล่นแต่ละคนผ่าน BindableEvent ได้อย่างไร

ทำเป็นโมดูล

ตอนเริ่มไม่จำเป็นต้องมี ModuleScript Script ตัวเดียวอ่านง่ายกว่าขณะที่คุณกำลังสร้างเกม แยกมันเมื่อสคริปต์อื่นต้องเรียกฟังก์ชันของรอบ หรือเมื่อคุณอยากย้ายการตั้งค่าไปไว้ใน ModuleScript ร่วมตัวเดียวที่ทั้งเซิร์ฟเวอร์และ UI ของคุณ require ได้ จนถึงตอนนั้น แอตทริบิวต์ State บน RoundInfo และแอตทริบิวต์ InRound บนผู้เล่นแต่ละคนทำหน้าที่เป็นอินเทอร์เฟซสาธารณะของระบบรอบเกมอยู่แล้ว: สคริปต์ใดก็ฟังมันได้

ข้อผิดพลาดที่พบบ่อยและวิธีแก้

เปิดหน้าต่าง Output (ผ่านเมนู Window ใน Studio หรือแท็บ Script) ก่อนกด Play ปัญหาส่วนใหญ่ของระบบรอบเกมแสดงคำเตือนหรือข้อผิดพลาดที่นั่น พร้อมชื่อสคริปต์และเลขบรรทัด

ค้างที่ "Waiting for players (1/2)"

คุณทดสอบคนเดียว แต่ MIN_PLAYERS เป็น 2 ตั้งเป็น 1 สำหรับการทดสอบคนเดียว หรือทดสอบในโหมด Server & Clients ด้วย 2 ไคลเอนต์

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

ไม่มีโฟลเดอร์ ชื่อพิมพ์ผิด หรืออยู่ผิดเซอร์วิส ต้องเป็น Folder ชื่อ Maps ตรงตัว อยู่ใน ServerStorage โดยตรง คำเตือนแบบเดียวกันสำหรับ RoundInfo ใน LocalScript หมายความว่าสคริปต์ RoundSystem ไปไม่ถึงการสร้างมัน: มันถูกปิด มีข้อผิดพลาด หรือยังรอโฟลเดอร์ Maps อยู่

หลังเทเลพอร์ต ผู้เล่นตกทะลุแผนที่

พาร์ตของแผนที่ไม่ได้ Anchored สำเนาจึงพังทลายทันทีที่อยู่ใน Workspace เลือกแผนที่ Anchor พาร์ตทั้งหมด และตรวจว่าพาร์ตจุดเกิดอยู่เหนือพื้น ไม่ใช่ข้างใน

ผู้เล่นที่ตกรอบเกิดใหม่บนสนาม

มี SpawnLocation อยู่ในแผนที่ เปลี่ยนเป็น Part ธรรมดาในโฟลเดอร์ Spawns ของแผนที่นั้น

รอบไม่จบเมื่อทุกคนตาย

ตรวจว่าดาเมจของคุณฆ่า Humanoid จริง (พลังชีวิตถึง 0) ไม่ใช่แค่ขยับหรือ Anchor ผู้เล่น ถ้าคุณปิดสถานะ Dead ของ Humanoid ไว้ Died จะไม่ทำงานเลย และรอบต้องเดินจนหมดเวลา

ลูปรอบเกมหยุดถาวรหลังข้อผิดพลาดครั้งเดียว

ลูปทำงานในเธรดเดียว ข้อผิดพลาดในสถานะใดก็ทำให้มันจบ อ่านข้อผิดพลาดใน Output แก้บรรทัดนั้น แล้วทดสอบใหม่ สาเหตุที่พบบ่อย: สคริปต์ถูกแก้ให้ใช้ player.Character.Humanoid โดยไม่ตรวจว่าตัวละครมีอยู่

ทำด้วย RoCode

ถ้าไม่อยากประกอบทั้งหมดนี้เอง RoCode ทำให้ใน place ที่คุณเปิดอยู่ได้ มันคือเอเจนต์ AI ที่ทำงานผ่านปลั๊กอินสำหรับ Roblox Studio สคริปต์และพาร์ตจึงปรากฏใน Explorer ของคุณ ไม่ใช่ในหน้าต่างแชตที่ต้องก๊อปมาวาง

คุณพิมพ์

เพิ่มระบบรอบเกม: ช่วงพัก 20 วินาทีที่ต้องมี 2 ผู้เล่น แผนที่สุ่มจาก ServerStorage.Maps เทเลพอร์ตทุกคนไปยังพาร์ตจุดเกิดของแผนที่ รอบละ 2 นาทีที่ผู้เล่นคนสุดท้ายที่รอดเป็นผู้ชนะ เพิ่ม Win ใน leaderstats และแสดงสถานะและตัวจับเวลาที่ด้านบนของจอ

RoCode ทำให้
  • สำรวจ place ของคุณก่อนได้ด้วย List Children, Search Game และ Search Scripts เพื่อใช้โฟลเดอร์ Maps และสคริปต์ leaderstats ของคุณ แทนที่จะเพิ่มชุดที่สอง
  • สร้าง Script รอบเกมใน ServerScriptService และ LocalScript ตัวจับเวลาด้วย Create Script และวางสนามจากสิ่งก่อสร้างสำเร็จรูปด้วย Place Prefab ได้ ถ้าคุณยังไม่มีแผนที่
  • ตรวจการคอมไพล์ของทุกสคริปต์ใน Studio ด้วย Check Script ก่อนจบ มันจับข้อผิดพลาดทางไวยากรณ์ ไม่ใช่ข้อผิดพลาดของตรรกะรอบเกม
  • หลังเพลย์เทสต์ของคุณ Check Output อ่านบรรทัด Server และ Client จากเพลย์เทสต์ล่าสุด เพื่อแก้ข้อผิดพลาดขณะรัน

กับปลั๊กอิน 3.9 ขึ้นไป RoCode รันเพลย์เทสต์สั้น ๆ และอ่านข้อผิดพลาดได้ และกับปลั๊กอิน 3.9.11 ขึ้นไปจะควบคุมตัวละครทดสอบได้หนึ่งตัว แต่มันไม่ทดสอบแบบหลายผู้เล่น ดังนั้นให้เล่นรอบเองในโหมด Server & Clients ทุกชุดการเปลี่ยนแปลงเป็นจุดย้อนกลับใน Studio ลูปรอบเกมเป็นพื้นฐานของหลายเกม และการสร้างเกม Roblox ทั้งเกมด้วย AI ทีละระบบมักเริ่มจากลูปแบบนี้ RoCode เชื่อมกับ Studio อย่างไร

คำถามที่พบบ่อย

จะทำระบบรอบเกมแบบมีทีมใน Roblox ได้อย่างไร?

เพิ่มอ็อบเจกต์ Team ในเซอร์วิส Teams และตั้ง USE_TEAMS = true ในสคริปต์รอบเกม Roblox จัดผู้เล่นที่เข้ามาเข้าทีมที่จัดอัตโนมัติได้ซึ่งมีสมาชิกน้อยที่สุด และรอบจะจบเมื่อผู้เล่นที่ยังมีชีวิตเหลืออยู่ในทีมเดียว

จะแสดงการนับถอยหลังให้ผู้เล่นทุกคนได้อย่างไร?

ตั้งวินาทีที่เหลือจากเซิร์ฟเวอร์เป็นแอตทริบิวต์บนอ็อบเจกต์ใน ReplicatedStorage แล้วฟังด้วย GetAttributeChangedSignal ใน LocalScript ที่อัปเดต TextLabel เหมือนในขั้นตอนที่ 3 ผู้เล่นที่เข้ามาทีหลังได้ค่าปัจจุบันทันที

ในลูปรอบเกมควรใช้อะไร: wait() หรือ task.wait()?

ใช้ task.wait() Roblox ระบุว่า wait() แบบ global เลิกใช้แล้วและถูกแทนด้วย task.wait()

จะเทเลพอร์ตผู้เล่นไปยัง place อื่นทุกรอบได้อย่างไร?

นั่นเป็นเครื่องมืออีกตัว คู่มือนี้ย้ายตัวละครภายในเซิร์ฟเวอร์เดียวด้วย PivotTo การส่งผู้เล่นไปยัง place อื่นในเกมของคุณใช้ TeleportService ซึ่งย้ายพวกเขาไปเซิร์ฟเวอร์อื่น คู่มือเทเลพอร์ตสร้างประตูมิติที่ทำแบบนี้ พร้อมลองใหม่ถ้าการเทเลพอร์ตล้มเหลว

ทำไมผู้เล่นชะงักไปชั่วครู่หลังเทเลพอร์ต?

เมื่อเปิด instance streaming ไคลเอนต์ยังไม่ได้รับแผนที่ การเรียก RequestStreamAroundAsync ในสคริปต์ระหว่างนับถอยหลัง "เตรียมพร้อม" ขอให้เอนจินส่งมันไปก่อน GET_READY_SECONDS ที่ยาวขึ้นให้เวลากับการเชื่อมต่อที่ช้ามากขึ้น

แหล่งข้อมูลและบทความแนะนำ

วิธีตรวจโค้ด: ทุกสคริปต์ในหน้านี้ผ่านตัวตรวจชนิดข้อมูลแบบ strict ของ Luau พร้อมคำจำกัดความของ Roblox API (luau-lsp, 20 พฤศจิกายน 2569) การตรวจชนิดข้อมูลจับได้เฉพาะชื่อ API ที่พิมพ์ผิดและชนิดข้อมูลที่ไม่ถูกต้อง ไม่ได้ตรวจตรรกะของเกม ดังนั้นควรทดสอบใน Studio ก่อนเผยแพร่

ลองใช้ RoCode กับเกมของคุณเอง

มีเครดิตฟรีทุกวัน ไม่ต้องใช้บัตร ติดตั้งปลั๊กอิน อธิบายฟีเจอร์ที่ต้องการ แล้วดูผลลัพธ์ใน Studio