Οδηγός · Συστήματα παιχνιδιού

Πώς να φτιάξεις σύστημα γύρων στο Roblox Studio

Τα περισσότερα παιχνίδια με γύρους στο Roblox τρέχουν τον ίδιο βρόχο: περιμένουν παίκτες, μετρούν αντίστροφα ως το μηδέν, φορτώνουν έναν χάρτη, τηλεμεταφέρουν όλους εκεί, τρέχουν ένα χρονόμετρο, βγάζουν νικητή και καθαρίζουν. Σε αυτόν τον οδηγό φτιάχνουμε αυτόν τον βρόχο ως ένα ευανάγνωστο script του server, προσθέτουμε ένα χρονόμετρο που βλέπει κάθε παίκτης και εξετάζουμε τις περιπτώσεις όπου χαλάνε τα αντιγραμμένα scripts: παίκτες που πεθαίνουν, φεύγουν ή μπαίνουν στη μέση του γύρου.

Ενημερώθηκε 20 Νοεμβρίου 202616 λεπτά ανάγνωσηςΣυντάκτης:

Με λίγα λόγια

Γράψτε ένα Script του server στο ServerScriptService που περνά κυκλικά από ένα σταθερό σύνολο καταστάσεων: intermission (περιμένει τον απαιτούμενο αριθμό παικτών και μετά αντίστροφη μέτρηση), φόρτωση χάρτη (κλωνοποιεί έναν τυχαίο χάρτη από το ServerStorage στο Workspace), τηλεμεταφορά (μεταφέρει κάθε ζωντανό χαρακτήρα σε ένα spawn part με PivotTo), γύρος (τρέχει το χρονόμετρο ώσπου να τελειώσει ο χρόνος ή να μείνει ένας παίκτης ή μία ομάδα) και εκκαθάριση (δίνει Wins, κάνει respawn τους επιζώντες, διαγράφει τον χάρτη).

  • Τρέξτε τον βρόχο μόνο στον server. Δημοσιεύστε την κατάσταση και τα δευτερόλεπτα που απομένουν ως attributes σε ένα Folder στο ReplicatedStorage, και αφήστε ένα LocalScript να τα δείχνει.
  • Κρατήστε έναν πίνακα με όσους είναι ακόμα στον γύρο. Αφαιρέστε έναν παίκτη όταν πεθάνει το Humanoid του, διαγραφεί ο χαρακτήρας του ή φύγει.
  • Τηλεμεταφέρετε μόνο τους παίκτες που ο χαρακτήρας τους είναι ζωντανός τη στιγμή που ξεκινά ο γύρος. Όποιος μπήκε αργότερα περιμένει στο lobby τον επόμενο.
Σε αυτή τη σελίδα
  1. Πώς λειτουργεί
  2. 1. Lobby και χάρτες
  3. 2. Script γύρων
  4. Πώς λειτουργούν οι καταστάσεις
  5. 3. UI χρονομέτρου
  6. Παίκτες στη μέση του γύρου
  7. Επεκτάσεις
  8. Common errors
  9. Με το RoCode
  10. Συχνές ερωτήσεις
  11. Πηγές και περαιτέρω ανάγνωση

Πώς λειτουργεί ένα σύστημα γύρων

ΕικονογράφησηΤα έτοιμα scripts γύρων σε παιχνίδι που τρέχει, επιταχυμένα.

Ένα σύστημα γύρων είναι μια μηχανή καταστάσεων. Κάθε στιγμή ο server βρίσκεται σε ακριβώς μία κατάσταση, κάθε κατάσταση έχει μία δουλειά και μία συνθήκη τον περνά στην επόμενη. Αν το γράψετε έτσι, όλη η λογική βρίσκεται σε ένα σημείο και δεν εμφανίζεται το κλασικό bug όπου ο βρόχος του χρονομέτρου και ο βρόχος του γύρου προσπαθούν και οι δύο να τελειώσουν τον ίδιο γύρο.

Οι καταστάσεις του βρόχου γύρων σε αυτόν τον οδηγό
ΚατάστασηΤι κάνει ο serverΠότε προχωρά
WaitingΔείχνει "Waiting for players (1/2)"Ο server έχει αρκετούς παίκτες
IntermissionΜετρά αντίστροφα όσο όλοι είναι στο lobbyΤελείωσε η αντίστροφη μέτρηση (ή επιστροφή στο Waiting αν έφυγαν παίκτες)
StartingΑντιγράφει έναν τυχαίο χάρτη στο Workspace, δείχνει το όνομά του, ζητά από τους clients να τον φορτώσουνΤελείωσε η σύντομη αντίστροφη μέτρηση "ετοιμαστείτε"
InRoundΤηλεμεταφέρει τους ζωντανούς παίκτες, τρέχει το χρονόμετρο, αφαιρεί όσους πέθαναν ή έφυγανΤελείωσε ο χρόνος ή έμεινε ένας παίκτης ή μία ομάδα
ResultsΔίνει Win σε όλους όσοι είναι ακόμα ζωντανοί και δείχνει ποιος νίκησεΠέρασαν λίγα δευτερόλεπτα
CleanupΚάνει respawn τους επιζώντες στο lobby και διαγράφει τον χάρτηΑμέσως, και μετά ο βρόχος ξεκινά από την αρχή

Κάθε κατάσταση την ελέγχει ο server. Οι clients μόνο δείχνουν ό,τι τους λέει ο server. Μια αντίστροφη μέτρηση σε LocalScript αποκλίνει από την πραγματική, είναι λάθος για όσους μπήκαν αργότερα και μπορεί να την αλλάξει ένας exploiter. Αν ο διαχωρισμός server και client είναι κάτι νέο για εσάς, διαβάστε πρώτα το Script vs LocalScript vs ModuleScript.

Βήμα 1: Φτιάξτε το lobby, τους χάρτες και το stat Wins

  1. Χτίστε ένα lobby στο Workspace με ένα SpawnLocation. Ελέγξτε ότι έχει τσεκαρισμένη την ιδιότητα Neutral, ώστε κάθε παίκτης να κάνει spawn εδώ, να περιμένει εδώ και να επιστρέφει εδώ όταν αποκλείεται.
  2. Στο ServerStorage προσθέστε ένα Folder με όνομα Maps. Τα αντικείμενα στο ServerStorage δεν στέλνονται ποτέ στους παίκτες, οπότε οι χάρτες που δεν χρησιμοποιούνται δεν τους κοστίζουν τίποτα.
  3. Φτιάξτε κάθε χάρτη ως Model μέσα στο Maps, με Anchored parts. Χτίστε τον μακριά από το lobby (μερικές εκατοντάδες studs αρκούν), γιατί το αντίγραφο εμφανίζεται ακριβώς εκεί όπου τον χτίσατε, και οι παίκτες που αποκλείστηκαν δεν πρέπει να μπορούν να ξαναμπούν περπατώντας.
  4. Μέσα σε κάθε χάρτη προσθέστε ένα Folder με όνομα Spawns και μέσα του ένα 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

Το script γύρων προσθέτει 1 σε ένα IntValue με όνομα Wins μέσα στον φάκελο leaderstats του παίκτη. Αν το παιχνίδι σας δεν έχει ακόμα leaderstats, προσθέστε αυτό το σύντομο script. Αν ήδη υπάρχει, για παράδειγμα η έκδοση με αποθήκευση από τον οδηγό για leaderboard, παραλείψτε το: δύο scripts που δημιουργούν 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 μπορεί να μπείτε πριν ξεκινήσει αυτό το script, οπότε ρυθμίζουμε όσους είναι ήδη εδώ
for _, player in Players:GetPlayers() do
	setupLeaderstats(player)
end

Αυτά τα Wins μηδενίζονται όταν ο παίκτης φεύγει. Για να διατηρούνται ανάμεσα στις συνεδρίες, πάρτε την έκδοση με DataStore από τον οδηγό για leaderboard.

Βήμα 2: Προσθέστε το script γύρων

Βάλτε ένα 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()

-- Ό,τι δείχνει η οθόνη κάθε παίκτη αποθηκεύεται σε attributes σε αυτόν τον φάκελο.
-- Τα attributes που ορίζει ο server αναπαράγονται σε όλους τους clients, και σε όσους μπήκαν αργότερα.
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
	-- Ανακατεύουμε, ώστε οι παίκτες να μην πέφτουν στο ίδιο spawn σε κάθε γύρο
	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 (στα rigs 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 ζητάμε από κάθε client να φορτώσει τον χάρτη πριν φτάσει ο χαρακτήρας
	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 του, οπότε το ανεβάζουμε στο ύψος όρθιου χαρακτήρα πάνω από το 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. Στέλνουμε τους επιζώντες πίσω στο lobby, μετά διαγράφουμε τον χάρτη.
local function cleanup(map: Model, survivors: { Player })
	for _, player in survivors do
		if player.Parent then -- ακόμα στον server
			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

Ό,τι έχει σημασία συμβαίνει εδώ, στον server: ποιος είναι στον γύρο, το χρονόμετρο, ο νικητής και τα Wins. Οι clients λαμβάνουν μόνο τρία attributes στο ReplicatedStorage.RoundInfo (State, Status και TimeLeft) και το attribute InRound σε κάθε παίκτη.

Πώς λειτουργεί κάθε κατάσταση

Αναμονή και intermission

Το runIntermission πρώτα κρατά τον βρόχο ώσπου το #Players:GetPlayers() να φτάσει το MIN_PLAYERS. Μετά μετρά αντίστροφα ένα δευτερόλεπτο τη φορά με task.wait(1) και σε κάθε χτύπο ελέγχει τον αριθμό των παικτών. Αν κάποιος έφυγε και ο server έπεσε κάτω από το ελάχιστο, επιστρέφει false και ο κύριος βρόχος ξεκινά πάλι από το Waiting, οπότε ένας γύρος δεν ξεκινά ποτέ με ένα άτομο.

Επιλογή και φόρτωση χάρτη

Το loadMap μαζεύει όλα τα Model στο ServerStorage.Maps, αφαιρεί τον χάρτη του προηγούμενου γύρου αν υπάρχει από πού να διαλέξει και παίρνει έναν με Random:NextInteger. Μετά κλωνοποιεί τον χάρτη στο Workspace. Το πρωτότυπο μένει ανέγγιχτο στο ServerStorage, οπότε κάθε γύρος ξεκινά με φρέσκο αντίγραφο: ό,τι έσπασαν ή μετακίνησαν οι παίκτες στον προηγούμενο γύρο εξαφανίζεται.

Στα νέα places είναι ενεργό το instance streaming: ο client έχει μόνο τα parts κοντά στον χαρακτήρα του. Πριν από την τηλεμεταφορά το script καλεί Player:RequestStreamAroundAsync για κάθε παίκτη, και αυτό ζητά από τη μηχανή να στείλει στον client την περιοχή γύρω από τον χάρτη κατά την αντίστροφη μέτρηση "ετοιμαστείτε". Χωρίς αυτό, οι παίκτες μπορεί να φτάσουν πριν φορτωθεί το πάτωμα και να παγώσουν για μια στιγμή.

Τηλεμεταφορά παικτών με PivotTo

Μετά την αντίστροφη μέτρηση το script φτιάχνει τη λίστα συμμετεχόντων από τους παίκτες των οποίων ο χαρακτήρας υπάρχει, είναι ακόμα στον κόσμο και έχει Humanoid με υγεία πάνω από 0 και root part. Αυτός ο έλεγχος γίνεται μετά την αντίστροφη μέτρηση, οπότε όποιος πέθανε ή έφυγε στη διάρκειά της δεν μπαίνει στη λίστα.

Κάθε συμμετέχων μεταφέρεται με character:PivotTo(cframe). Η τεκμηρίωση του Roblox αναφέρει το PivotTo ως τον βασικό τρόπο για να κινείτε μοντέλα από script, και κινεί όλα τα μέρη του χαρακτήρα μαζί. Το να ορίσετε το HumanoidRootPart.Position δεν είναι το ίδιο: το Roblox προσαρμόζει τις συνδέσεις έτσι ώστε να κινείται μόνο αυτό το μέρος, και το υπόλοιπο σώμα μπορεί να μείνει πίσω. Το pivot του χαρακτήρα είναι το root part του, οπότε ο στόχος είναι το CFrame του spawn part, ανεβασμένο κατά το μισό ύψος του part συν το ύψος στο οποίο το root part στέκεται πάνω από το πάτωμα. Το rootHeight το υπολογίζει με τον τύπο από την τεκμηρίωση του Roblox για το Humanoid.HipHeight: το μισό ύψος του root part συν το HipHeight, συν το μήκος του ποδιού στα rigs R6. Έτσι τα avatars με αλλαγμένη κλίμακα και τα custom avatars δεν κολλάνε μέσα στο part ούτε πέφτουν πάνω του από ψηλά. Το CFrame περιλαμβάνει την περιστροφή, οπότε οι παίκτες κοιτάζουν προς την ίδια κατεύθυνση με το spawn part: γυρίστε τα parts ώστε όλοι να κοιτάζουν το κέντρο του χάρτη.

Αν οι παίκτες είναι περισσότεροι από τα spawn parts, το script ξαναρχίζει από το πρώτο part και οι παίκτες καταλήγουν ο ένας πάνω στον άλλον, οπότε προσθέστε τουλάχιστον τόσα spawns όσος είναι ο μέγιστος αριθμός παικτών σας.

Αν χρησιμοποιείτε επίσης τον έλεγχο ταχύτητας από τον οδηγό για sprint, προσθέστε player:SetAttribute("MovementCheckSkip", true) αμέσως μετά το character:PivotTo(...) στο startRound, ώστε η τηλεμεταφορά να μη μετρηθεί ως υπέρβαση ταχύτητας.

Χρονόμετρο γύρου και συνθήκες λήξης

Το runRound χτυπά μία φορά το δευτερόλεπτο. Σε κάθε χτύπο ενημερώνει την κατάσταση (πόσοι παίκτες έμειναν) και τα δευτερόλεπτα που απομένουν, και μετά μετρά τις ζωντανές πλευρές. Ο γύρος τελειώνει με έναν από τρεις τρόπους:

  • Τελείωσε ο χρόνος. Ο βρόχος for φτάνει στο 1 και τερματίζει.
  • Έμεινε μία πλευρά. Πλευρά είναι ένας παίκτης ή μια ομάδα, αν είναι ενεργό το USE_TEAMS. Ο έλεγχος λειτουργεί μόνο αν ο γύρος ξεκίνησε με δύο ή περισσότερες πλευρές, οπότε ένα τεστ μόνοι σας δεν τελειώνει τη στιγμή που ξεκίνησε.
  • Δεν έμεινε κανείς. Όλοι πέθαναν ή έφυγαν, και ο γύρος τελειώνει χωρίς νικητή.

Ο έλεγχος μία φορά το δευτερόλεπτο σημαίνει ότι ο γύρος μπορεί να συνεχιστεί ως ένα δευτερόλεπτο μετά τον τελευταίο αποκλεισμό, κάτι σχεδόν ανεπαίσθητο σε χρονόμετρο γύρου.

Απονομή Wins και εμφάνιση αποτελέσματος

Ο κανόνας σε αυτό το script είναι απλός: νικούν όλοι όσοι είναι ζωντανοί τη στιγμή που τελειώνει ο γύρος. Αυτό καλύπτει και τον τελευταίο παίκτη που επέζησε, και την τελευταία ομάδα που επέζησε, και τη λειτουργία "αντέξτε ώσπου να τελειώσει το χρονόμετρο" με μία γραμμή λογικής. Το finishRound προσθέτει 1 στα Wins κάθε νικητή, σταματά να τους παρακολουθεί και δείχνει ένα μήνυμα όπως "Alex wins!" για RESULTS_SECONDS. Αν θέλετε να μην υπάρχει νικητής όταν τελειώνει ο χρόνος, παραλείψτε το awardWin και αλλάξτε το μήνυμα όταν το sidesLeft είναι μεγαλύτερο από 1. Σε κάθε περίπτωση συνεχίστε να επιστρέφετε τη λίστα, γιατί η εκκαθάριση τη χρησιμοποιεί για να γυρίσει τους επιζώντες στο lobby.

Εκκαθάριση

Οι επιζώντες στέκονται ακόμα στον χάρτη, οπότε το cleanup τους κάνει respawn στο lobby με Player:LoadCharacterAsync(), που αντικαθιστά το παλιό LoadCharacter, και μετά διαγράφει το αντίγραφο του χάρτη. Κάθε respawn τρέχει στο δικό του task.spawn μέσα σε pcall, γιατί η κλήση περιμένει να φορτωθεί ο χαρακτήρας και μπορεί να αποτύχει αν ο παίκτης φεύγει εκείνη ακριβώς τη στιγμή. Οι παίκτες που αποκλείστηκαν δεν χρειάζονται τίποτα: έχουν ήδη κάνει respawn μόνοι τους στο lobby.

Βήμα 3: Δείξτε το χρονόμετρο και την κατάσταση σε κάθε παίκτη

Ο server δημοσιεύει τρία attributes στο ReplicatedStorage.RoundInfo: State (μια σταθερή λέξη όπως InRound, για τα scripts), Status (κείμενο για ανθρώπους) και TimeLeft (δευτερόλεπτα). Τα attributes που ορίζει ένα script του server σε αντικείμενο που αναπαράγεται φτάνουν αυτόματα σε κάθε client, και ένας παίκτης που μπαίνει στη μέση του γύρου παίρνει αμέσως τις τρέχουσες τιμές. Γι' αυτό για χρονόμετρο ταιριάζουν καλύτερα από ένα 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 σε κάθε spawn του χαρακτήρα, και στο respawn της εκκαθάρισης. Το script τότε ξαναδιαβάζει τα τρέχοντα attributes, οπότε η ετικέτα δεν μένει ποτέ παλιά.

Ο client μόνο διαβάζει. Τίποτα από όσα αλλάξει ένας παίκτης στην οθόνη του δεν επηρεάζει το πραγματικό χρονόμετρο, γιατί οι αλλαγές attributes από LocalScript μένουν σε αυτόν τον έναν client. Για αντίστροφη μέτρηση με δέκατα του δευτερολέπτου, ο server μπορεί αντί γι' αυτό να κρατά σε attribute τον χρόνο λήξης από το workspace:GetServerTimeNow(), και κάθε client σε κάθε καρέ να αφαιρεί από αυτόν το δικό του workspace:GetServerTimeNow().

Αν το παιχνίδι σας ανοίγει με κύριο μενού, το RoundHud εμφανίζεται όταν ο παίκτης πατήσει Play, γιατί το StarterGui αντιγράφεται στον παίκτη μόνο αφού κάνει spawn ο χαρακτήρας του. Οι παίκτες που είναι ακόμα στο μενού δεν έχουν χαρακτήρα, οπότε δεν τηλεμεταφέρονται ποτέ σε γύρο.

Παίκτες που πεθαίνουν, φεύγουν ή μπαίνουν στη μέση του γύρου

Αυτές τις περιπτώσεις είναι εύκολο να τις ξεχάσετε όταν γράφετε για πρώτη φορά script γύρων. Αν κάποια δεν καλύπτεται, συνήθως βλέπετε ένα σφάλμα στο Output ή έναν γύρο που δεν τελειώνει ποτέ. Να τι κάνει το παραπάνω script σε καθεμία.

Ακραίες περιπτώσεις και πώς τις χειρίζεται το script γύρων
ΚατάστασηΤι συμβαίνειΠού στο script
Ο παίκτης πεθαίνει στον γύρο (σκοτώθηκε, έκανε reset, έπεσε)Αφαιρείται από τον γύρο και κάνει respawn στο lobby μετά από Players.RespawnTime (προεπιλογή 5 δευτερόλεπτα).Το humanoid.Died καλεί eliminate
Ο χαρακτήρας διαγράφηκε χωρίς θάνατοΌπως και στον θάνατο: ο παίκτης αποκλείστηκε.Το player.CharacterRemoving καλεί eliminate
Ο παίκτης φεύγει από τον serverΑφαιρείται, οι συνδέσεις του αποσυνδέονται και ο επόμενος χτύπος ξαναμετρά τις πλευρές.Το Players.PlayerRemoving καλεί eliminate
Ο παίκτης μπαίνει στη μέση του γύρουΚάνει spawn στο lobby, βλέπει ζωντανά την κατάσταση και το χρονόμετρο και μπαίνει στον επόμενο γύρο.Οι συμμετέχοντες επιλέγονται μόνο στο startRound
Ο παίκτης ήταν νεκρός τη στιγμή που ξεκίνησε ο γύροςΔεν τηλεμεταφέρεται, περιμένει στο lobby.getLivingCharacter
Όλοι έφυγαν ή πέθανανΟ γύρος τελειώνει με "Nobody survived" και ο βρόχος ξεκινά από την αρχή: Intermission αν ο server έχει ακόμα αρκετούς παίκτες, αλλιώς Waiting.sidesLeft == 0 στο runRound

Το eliminate είναι γραμμένο ώστε να μπορεί να καλεστεί με ασφάλεια πολλές φορές για τον ίδιο παίκτη. Ένας παίκτης που πέθανε και έκανε respawn πυροδοτεί και το Died και το CharacterRemoving, και όποιος φεύγει μπορεί να πυροδοτήσει και τα τρία συμβάντα· κάτι κάνει μόνο η πρώτη κλήση.

Επεκτάσεις: ομάδες, ψηφοφορία για χάρτη και συμβάντα γύρου

Η τελευταία ομάδα που επιζεί

Ορίστε USE_TEAMS = true και μετά προσθέστε αντικείμενα Team στην υπηρεσία Teams στο Explorer, το καθένα με δικό του όνομα και TeamColor. Από προεπιλογή το Roblox βάζει κάθε παίκτη που μπαίνει στην ομάδα με αυτόματη ανάθεση που έχει τα λιγότερα μέλη. Όταν φεύγουν παίκτες, δεν ξαναμοιράζει τις ομάδες, οπότε σε μεγάλες συνεδρίες οι ομάδες μπορεί να γίνουν άνισες. Αφήστε το SpawnLocation του lobby Neutral, ώστε όλες οι ομάδες να κάνουν spawn εκεί. Τότε ο γύρος τελειώνει όταν οι ζωντανοί παίκτες έχουν μείνει μόνο σε μία ομάδα, και το αποτέλεσμα φαίνεται σαν "Red wins!".

Για μορφή "ένας εναντίον όλων" (ένας κυνηγός, οι υπόλοιποι επιβιώνουν) διαλέξτε στο startRound έναν τυχαίο συμμετέχοντα και πριν από την τηλεμεταφορά ορίστε το Team του στην ομάδα του κυνηγού. Απενεργοποιήστε το AutoAssignable στην ομάδα του κυνηγού, ώστε να μη μπαίνουν ποτέ εκεί νέοι παίκτες, και στο cleanup γυρίστε τον κυνηγό στην ομάδα των επιζώντων. Τότε δουλεύουν οι ίδιες συνθήκες λήξης: ο κυνηγός νικά αν αποκλειστούν όλοι οι επιζώντες, και οι επιζώντες νικούν αν αντέξουν ως το τέλος του χρονομέτρου, με την προϋπόθεση ότι παραλείπετε το awardWin του κυνηγού όταν τελειώνει ο χρόνος.

Ψηφοφορία παικτών για χάρτη

Για ψηφοφορία ο client πρέπει να επικοινωνεί με τον server, άρα χρειάζεται ένα RemoteEvent. Κατά το intermission ο server δημοσιεύει ως attributes δύο ή τρία ονόματα χαρτών, κάθε client στέλνει μέσω του RemoteEvent το όνομα που πάτησε, και ο server μετρά τις ψήφους πριν τρέξει το loadMap. Ο server πρέπει να ελέγχει κάθε ψήφο: ότι το όρισμα είναι string, ότι είναι μία από τις τρέχουσες επιλογές, ότι η κατάσταση είναι Intermission και ότι κάθε παίκτης μετράει μία φορά (κρατήστε τις ψήφους σε πίνακα με κλειδί το Player, ώστε μια δεύτερη ψήφος να αντικαθιστά την πρώτη, και αδειάστε τον στο PlayerRemoving). Ο οδηγός για RemoteEvent εξηγεί αναλυτικά αυτό το μοτίβο ελέγχων.

Δίνοντας εργαλείο στην αρχή του γύρου

Άλλα scripts μπορούν να αντιδρούν στον γύρο χωρίς να αγγίζουν το RoundSystem. Το script γύρων βάζει σε κάθε παίκτη το attribute InRound όταν τον τηλεμεταφέρει και το αφαιρεί όταν ο παίκτης αποκλείεται. Αυτό το script το ακούει και δίνει σε κάθε παίκτη ένα αντίγραφο του 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 στην εκκαθάριση το αδειάζει για τους επιζώντες, οπότε μετά τον γύρο το εργαλείο δεν υπάρχει πια.

Αν χρειάζεστε όπλο για να μοιράσετε, φτιάξτε ένα σπαθί ή ένα όπλο με raycasts, κρατήστε το στο ServerStorage αντί για το StarterPack και αλλάξτε το "RoundTool" σε αυτό το script στο όνομά του.

NPC και άλλα αντικείμενα μόνο για τη διάρκεια του γύρου

Ό,τι πρέπει να υπάρχει μόνο κατά τον γύρο μπορεί να ζει μέσα στο μοντέλο του χάρτη: εχθροί, αντικείμενα που μαζεύονται, κινούμενες πλατφόρμες. Τα scripts μέσα σε μοντέλο στο ServerStorage δεν τρέχουν· μόλις το αντίγραφο βρεθεί στο Workspace ξεκινούν, και το map:Destroy() στην εκκαθάριση τα διαγράφει μαζί με όλα τα υπόλοιπα. Για να προσθέσετε εχθρούς που κυνηγούν τους παίκτες, φτιάξτε έναν με τον οδηγό pathfinding για NPC και βάλτε τον στον χάρτη. Για μια πτήση πάνω από τον χάρτη στην αρχή κάθε γύρου, ο οδηγός για cutscenes δείχνει πώς αυτό το script μπορεί να ξεκινά μια cutscene για κάθε παίκτη μέσω BindableEvent.

Πώς να το κάνετε module

Για αρχή δεν χρειάζεται ModuleScript. Ένα Script διαβάζεται πιο εύκολα όσο φτιάχνετε το παιχνίδι. Χωρίστε το όταν άλλα scripts χρειάζεται να καλούν συναρτήσεις του γύρου ή όταν θέλετε να βγάλετε τις ρυθμίσεις σε ένα κοινό ModuleScript που μπορούν να φορτώνουν με require και ο server και το UI σας. Ως τότε, το attribute State στο RoundInfo και το attribute InRound σε κάθε παίκτη λειτουργούν ήδη ως δημόσια διεπαφή του συστήματος γύρων: οποιοδήποτε script μπορεί να τα ακούει.

Συνηθισμένα λάθη και λύσεις

Ανοίξτε το παράθυρο Output (από το μενού Window στο Studio ή την καρτέλα Script) πριν πατήσετε Play. Τα περισσότερα προβλήματα με το σύστημα γύρων εμφανίζουν εκεί μια προειδοποίηση ή ένα σφάλμα με το όνομα του script και τον αριθμό γραμμής.

Κολλάει στο "Waiting for players (1/2)"

Δοκιμάζετε μόνοι σας και το MIN_PLAYERS είναι 2. Βάλτε 1 για τεστ μόνοι σας ή δοκιμάστε στη λειτουργία Server & Clients με 2 clients.

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

Ο φάκελος δεν υπάρχει, έχει τυπογραφικό λάθος στο όνομα ή βρίσκεται σε λάθος υπηρεσία. Πρέπει να είναι ένα Folder με όνομα ακριβώς Maps απευθείας μέσα στο ServerStorage. Η ίδια προειδοποίηση για το RoundInfo στο LocalScript σημαίνει ότι το script RoundSystem δεν έφτασε ποτέ να τον δημιουργήσει: είναι απενεργοποιημένο, σταμάτησε με σφάλμα ή περιμένει ακόμα τον φάκελο Maps.

Μετά την τηλεμεταφορά οι παίκτες πέφτουν μέσα από τον χάρτη

Τα parts του χάρτη δεν είναι anchored, οπότε το αντίγραφο διαλύεται μόλις βρεθεί στο Workspace. Επιλέξτε τον χάρτη, κάντε Anchored τα parts του και ελέγξτε ότι τα spawn parts είναι πάνω από το πάτωμα, όχι μέσα του.

Οι παίκτες που αποκλείστηκαν κάνουν respawn στην αρένα

Μέσα στον χάρτη υπάρχει SpawnLocation. Αντικαταστήστε το με ένα απλό Part στον φάκελο Spawns αυτού του χάρτη.

Ο γύρος δεν τελειώνει όταν πεθάνουν όλοι

Ελέγξτε ότι η ζημιά σας πραγματικά σκοτώνει το Humanoid (η υγεία φτάνει στο 0) και όχι ότι μετακινεί ή κάνει anchor τους παίκτες. Αν απενεργοποιήσατε την κατάσταση Dead στο Humanoid, το Died δεν πυροδοτείται ποτέ και ο γύρος πρέπει να φτάσει ως το τέλος του χρονομέτρου.

Ο βρόχος γύρων σταματά οριστικά μετά από ένα σφάλμα

Ο βρόχος τρέχει σε ένα νήμα, οπότε ένα σφάλμα σε οποιαδήποτε κατάσταση τον τερματίζει. Διαβάστε το σφάλμα στο Output, διορθώστε τη γραμμή και δοκιμάστε ξανά. Συχνή αιτία: το script άλλαξε ώστε να χρησιμοποιεί player.Character.Humanoid χωρίς να ελέγχει ότι ο χαρακτήρας υπάρχει.

Φτιάξτε το με το RoCode

Αν δεν θέλετε να τα φτιάξετε όλα αυτά με το χέρι, το RoCode μπορεί να τα κάνει στο place που έχετε ανοιχτό. Είναι ένας πράκτορας AI που δουλεύει μέσω ενός plugin για το Roblox Studio, οπότε τα scripts και τα parts εμφανίζονται στο Explorer σας και όχι σε ένα παράθυρο συνομιλίας από όπου θα έπρεπε να τα επικολλήσετε.

Εσείς γράφετε

Πρόσθεσε σύστημα γύρων: intermission 20 δευτερολέπτων που χρειάζεται 2 παίκτες, τυχαίος χάρτης από το ServerStorage.Maps, τηλεμεταφορά όλων στα spawn parts του χάρτη, γύροι των 2 λεπτών όπου νικά ο τελευταίος ζωντανός παίκτης, πρόσθεσε ένα Win στα leaderstats και δείξε την κατάσταση και το χρονόμετρο στο πάνω μέρος της οθόνης.

Το RoCode κάνει
  • Μπορεί πρώτα να εξετάσει το place σας με List Children, Search Game και Search Scripts, ώστε να χρησιμοποιήσει τον φάκελο Maps και το script leaderstats σας αντί να προσθέσει δεύτερο σετ
  • Δημιουργεί το Script γύρων στο ServerScriptService και το LocalScript του χρονομέτρου με Create Script και μπορεί να στήσει μια αρένα από τις έτοιμες κατασκευές του με Place Prefab, αν δεν έχετε ακόμα χάρτη
  • Ελέγχει ότι κάθε script κάνει compile μέσα στο Studio με Check Script πριν τελειώσει. Αυτό πιάνει συντακτικά λάθη, όχι λάθη στη λογική του γύρου
  • Μετά το δικό σας playtest, το Check Output διαβάζει τις γραμμές Server και Client από το τελευταίο playtest για να διορθώσει ένα σφάλμα κατά την εκτέλεση

Με το plugin 3.9 ή νεότερο το RoCode μπορεί να τρέξει ένα σύντομο playtest και να διαβάσει τα σφάλματα, και με το plugin 3.9.11 ή νεότερο μπορεί να ελέγχει έναν χαρακτήρα δοκιμής, αλλά δεν κάνει τεστ με πολλούς παίκτες, οπότε τρέξτε τους γύρους εσείς στη λειτουργία Server & Clients. Κάθε δέσμη αλλαγών είναι ένα σημείο αναίρεσης στο Studio. Ο βρόχος γύρων είναι η βάση πολλών παιχνιδιών, και η δημιουργία ολόκληρου παιχνιδιού Roblox με AI, σύστημα με σύστημα συχνά ξεκινά από έναν τέτοιο βρόχο. Πώς συνδέεται το RoCode με το Studio.

Συχνές ερωτήσεις

Πώς φτιάχνω σύστημα γύρων με ομάδες στο Roblox;

Προσθέστε αντικείμενα Team στην υπηρεσία Teams και ορίστε USE_TEAMS = true στο script γύρων. Το Roblox βάζει τους παίκτες που μπαίνουν στην ομάδα με αυτόματη ανάθεση που έχει τα λιγότερα μέλη, και ο γύρος τελειώνει όταν οι ζωντανοί παίκτες έχουν μείνει μόνο σε μία ομάδα.

Πώς δείχνω την αντίστροφη μέτρηση σε όλους τους παίκτες;

Ορίστε από τον server τα δευτερόλεπτα που απομένουν ως attribute σε ένα αντικείμενο στο ReplicatedStorage και ακούστε το με GetAttributeChangedSignal σε ένα LocalScript που ενημερώνει ένα TextLabel, όπως στο βήμα 3. Οι παίκτες που μπαίνουν αργότερα παίρνουν αμέσως την τρέχουσα τιμή.

Τι να χρησιμοποιήσω στον βρόχο γύρων: wait() ή task.wait();

Χρησιμοποιήστε task.wait(). Το Roblox σημειώνει το καθολικό wait() ως παρωχημένο και αντικατεστημένο από το task.wait().

Πώς τηλεμεταφέρω παίκτες σε άλλο place σε κάθε γύρο;

Αυτό είναι άλλο εργαλείο. Αυτός ο οδηγός μεταφέρει χαρακτήρες μέσα στον ίδιο server με PivotTo. Η αποστολή παικτών σε άλλο place του experience σας γίνεται μέσω του TeleportService, που τους μεταφέρει σε άλλο server. Ο οδηγός για τηλεμεταφορές φτιάχνει πύλες που το κάνουν αυτό, με επαναλήψεις αν η τηλεμεταφορά αποτύχει.

Γιατί οι παίκτες παγώνουν για μια στιγμή μετά την τηλεμεταφορά;

Με ενεργό instance streaming ο client δεν έχει λάβει ακόμα τον χάρτη. Η κλήση RequestStreamAroundAsync στο script κατά την αντίστροφη μέτρηση "ετοιμαστείτε" ζητά από τη μηχανή να τον στείλει νωρίτερα· ένα μεγαλύτερο GET_READY_SECONDS δίνει στις αργές συνδέσεις περισσότερο χρόνο.

Πηγές και περαιτέρω ανάγνωση

Πώς ελέγχθηκε ο κώδικας: κάθε script σε αυτή τη σελίδα περνά αυστηρό έλεγχο τύπων Luau με τους ορισμούς του Roblox API (luau-lsp, 20 Νοεμβρίου 2026). Ο έλεγχος τύπων πιάνει λάθη σε ονόματα API και λάθος τύπους, όχι όμως λάθη στη λογική του παιχνιδιού, γι' αυτό δοκιμάστε τα πάντα στο Studio πριν τη δημοσίευση.

Δοκιμάστε το RoCode στο παιχνίδι σας.

Δωρεάν credits κάθε μέρα, χωρίς κάρτα. Εγκαταστήστε το plugin, περιγράψτε μια λειτουργία και δείτε τι εμφανίζεται στο Studio.