Code die Spielschleife

Mit der erstellten Karte ist es Zeit, die Skripte zu bauen.Der Rest dieses Kurses wird sich stark darauf konzentrieren, alle verschiedenen Elemente der Spielschleife zu skripten.

Konfiguriere die Skripte

Das Battle-Royale wird eine Kombination aus Modulskripten und normalen Skripten verwenden. Im Folgenden sind die Skripte und ihre Funktionen aufgeführt.

Spielmanager	Skript. Führt Funktionen aus dem Match-Manager aus, indem es Variablen aus den Spiel-Einstellungen verwendet
Matchentwickler	Modul-Skript. Führt Funktionen aus, wie das Senden von Spielern in eine Arena oder das Verfolgen der Zeit in einem übereinstimmen.
Spieleinstellungen	Modul-Skript. Speichert häufig verwendete Variablen, die von anderen Skripten verwendet werden.

Erstellen Sie ein Modulskript namens GameSettings, um Variablen zu speichern, die von anderen Skripten verwendet werden, wie Match- und Unterbrechungsdauer.Diese Variablen werden vom GameManager-Skript später verwendet.

In ServerStorage , erstelle einen Ordner mit dem Namen ModuleScripts. In diesem Ordner erstelle ein neues Modulskript mit dem Namen GameSettings.

Öffne GameSettings und benenne den Modultisch um, um den Namen des Skript, das. PL: die Skriptszu entsprechen.


local GameSettings = {}

return GameSettings

Füge in der Modultabelle Variablen für die folgenden Verwendungen hinzu. Triff deine beste Vermutung für jeden Wert, du kannst ihn später immer ändern, wenn du testest.

Unterbrechungsdauer - Sekunden warten Spieler vor einem übereinstimmen.
Spielzeit - Länge eines Spiels in Sekunden.
Mindestspieler - Kleinstes benötigtes Anzahl von Spielern zum starten.
Übergangszeit - Zeit vor und nach einem Spiel in Sekunden. Macht den Übergang zwischen Teilen der Spielschleife weniger plötzlich.


local GameSettings = {}

-- Spielvariablen
GameSettings.intermissionDuration = 5
GameSettings.matchDuration = 10
GameSettings.minimumPlayers = 2
GameSettings.transitionTime = 5

return GameSettings

Skript, das. PL: die Skripts

Das zweite Skript, das mit dem GameManager verbunden ist, ist der MatchManager.Dieses Skript verwaltet Aufgaben wie das Starten des T timers oder das Zurücksetzen von Spielern, sobald das Spiel beendet ist.

Innerhalb von MatchManager ist eine Funktion namens prepareGame(), die das Spiel startet, indem sie Spieler in das übereinstimmenüberträgt.

In ServerStorage > ModuleScripts > füge ein Modulskript namens MatchManager hinzu. Benenne den Modultab um.


local MatchManager = {}

return MatchManager

Füge eine neue Modulfunktion zum MatchManager hinzu, die prepareGame() heißt. Füge eine Druckausgabe hinzu, um das Skript später zu testen.


local MatchManager = {}

function MatchManager.prepareGame()
	print("Game starting!")
end

return MatchManager

Die Hauptspielschleife wird im GameManager-Skript mit den gerade erstellten Variablen kodiert.Denken Sie daran, es gibt drei Phasen im Spielschleifen: Pause, Wettbewerb und Aufräumen & zurücksetzen.

Skript, das. PL: die Skripts

Dieses Skript ist ein normales Skript, das. PL: die Skripts, also legen Sie es in den ServerScriptService-Ordner, anstatt in den Modul-Skriptordner.Die tatsächliche Spielschleife wird in einer While-true-Schleife sein.

Im ServerScriptService erstellen Sie ein neues Skript mit dem Namen GameManager.

Füge eine Variable für den Service "ServerStorage" hinzu, der der Ort ist, an dem sich die Modulskripte befinden.Füge dann eine Variable für den Service "Spieler" hinzu, die zum Überprüfen der Spieleranzahl während der Pausen benötigt wird.


-- Dienste
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

Um die zuvor erstellten Module zu verwenden:

Setze eine Variable mit dem Namen moduleScripts an den Ort des Modulskript-Ordners.
Füge Variablen mit den Namen matchManager und gameSettings hinzu. Stelle jede Variable so ein, dass sie ihr jeweiliges Skript, das. PL: die Skriptserfordert.


-- Dienste
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

-- Modul-Skripte
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local matchManager = require(moduleScripts:WaitForChild("MatchManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))

Nach den Variablen füge eine while true do -Schleife hinzu. Alle Phasen des Spielschleifs gehen hinein, um sich unendlich wiederholen zu lassen.


-- Modul-Skripte
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local matchManager = require(moduleScripts:WaitForChild("MatchManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))

-- Hauptspielschleife
while true do

end

Code die Pause

Während der Spielschleife ununterbrochen läuft, sollte die Pause die Schleife unterbrechen und nur fortgesetzt werden, wenn es genug Spieler für ein übereinstimmengibt.Um diese Pause zu codieren, füge einen verschachtelten Wiederholungsschleife für die Pause in den While-Loop ein.Diese verschachtelte Schleife wird sich wiederholen, bis es genug Spieler gibt, wobei die Hauptschleife unterbrochen wird.Sobald es genug Spieler gibt, wird es ausgehen und Spieler in ein übereinstimmenübertragen.

Mit einer Wiederholungsschleife wird der Code in der Schleife mindestens einmal ausgeführt.Im Gegensatz zu einer While-Schleife prüft es seine Bedingung nicht, bis die Schleife endet.Dies gewährleistet, dass Spieler immer in die Lobby gehen, bevor ein übereinstimmenbeginnt.

In der while true do Schleife geben Sie repeat ein und drücken Enter, um mit dem Schlüsselwort until automatisch zu vervollständigen.
```
while true do
  repeat

  until
end
```

Überprüfe, ob die aktuelle Anzahl der Spieler (#Players:GetPlayers()) größer oder gleich der Variable minimumPlayers ist, die zuvor im Modul GameSettings erstellt wurde.


while true do
	repeat

	until #Players:GetPlayers() >= gameSettings.minimumPlayers
end

Füge im Wiederholungszyklus eine Druck statement hinzu, die sagt, dass die Pause beginnt.Verwende task.wait(), um für die Pause während der Pause mit intermissionDuration von GameSettings zu pausieren.


while true do
	repeat
		print("Starting intermission")
		task.wait(gameSettings.intermissionDuration)
	until #Players:GetPlayers() >= gameSettings.minimumPlayers
end

Teste und überprüfe, dass die Druckausgabe "Starting intermission" mindestens zweimal angezeigt wird.Die Nachricht zweimal zu sehen beweist, dass die Wiederholungsschleife nicht genug Spieler gefunden hat und erneut ausgeführt wurde.Du musst die Länge der Pause abwarten, bevor du die Nachricht zum zweiten Mal siehst.

Problemlösungstipps

An diesem Punkt, wenn du nicht wie beabsichtigt spawnst, versuche eine der folgenden Optionen.

task.wait() sollte innerhalb der Wiederholungsschleife sein.Ohne die Wartezeit wird das Skript in einer Sekunde zu oft ausgeführt, überlastet Roblox Studio und verursacht einen Fehler.
Im Modul Spieleinstellungen sollte die Variable intermissionDuration größer als 1 sein. Wenn sie niedriger ist, kann das Skript zu oft wiederholt werden, was zu Verzögerungsproblemen führt.

Beende die Pause

Sobald es genug Spieler gibt, lass sie eine kurze Übergangszeit warten.Dann sende sie ins Spiel, indem du die prepareGame()-Funktion in MatchManager aufrufst.Denken Sie daran, dass diese Funktion nur eine Zeile druckt, aber Sie fügen später mehr Code hinzu.

Am Ende der Wiederholungsschleife füge eine Druckausgabe hinzu, die sagt, dass die Pause vorbei ist, um deinen Codeszu testen.Dann folgen Sie es mit einer task.wait() mit der Variable von GameSetting's transitionTime.


while true do
	repeat
		print("Starting intermission")
		task.wait(gameSettings.intermissionDuration)
	until #Players:GetPlayers() >= gameSettings.minimumPlayers
	print("Intermission over")
	task.wait(gameSettings.transitionTime)
end

Halte den Code innerhalb des Umfangs der While-Schleife (zwischen do und end).Wenn Code außerhalb ist, wiederholen sich möglicherweise Teile deiner Spielschleife nicht und Spieler stecken nur in der Pause-Phase fest.

Nach der Wartezeit rufe die prepareGame() aus dem MatchManager-Modul auf.Wenn der Code ausgeführt wird, wird dies nur Text in das Ausgabe-Fenster drucken.Warte bis zum nächsten Abschnitt, um diesen Codeszu testen.


while true do
	repeat
		print("Starting intermission")
		task.wait(gameSettings.intermissionDuration)
	until #Players:GetPlayers() >= gameSettings.minimumPlayers

	print("Intermission over")
	task.wait(gameSettings.transitionTime)
	matchManager.prepareGame()
end

Wenn du nach diesem Projekt zum Skript hinzufügst, denke daran, dass Code unterhalb der while-true-Schleife nicht ausführenwird .Halte relevanten Code innerhalb der While-Schleife oder rufe Modulfunktionen aus der Hauptschleife auf.

Teste Mehrspieler-Spiele

Im Moment, um den Code ausführen zu lassen prepareGame(), muss er die Wiederholungsschleife verlassen.Aber um das zu tun, muss es mehr als einen Spieler:ingeben.Das bedeutet, wenn du die Spieltest-Schaltfläche verwendest, wird die Funktion nie ausgeführt, weil du der einzige Spieler im Spiel bist (es sei denn, deine minimale Anzahl von Spielern ist eine).Um dies zu testen, müssen Sie ein Mehrspieler-Spiel simulieren.

Starte einen lokalen Server

Um Code zu testen, der mehr als einen Spieler:inerfordert, erstelle einen lokalen Server.Während veröffentlichte Spiele normalerweise auf Roblox-Servern sind, simuliert ein lokaler Server ein Mehrspieler-Spiel auf deinem Computer mit simulierten Spielern.

Um einen lokalen Server zu starten, in der Test Registerkarte > Clients und Server Sektion > stelle die Spielerauswahl auf die Anzahl der Spieler in der Variable minimumPlayers von GameSetting ein.Diese Lektion verwendet 2 Spieler.
Klicken Sie auf Start, um den Server zu starten.
Warte einige Sekunden, bis der Server eingerichtet ist.Mehrere Fenster öffnen sich zusätzlich zu deinem ursprünglichen Studio-Fenster.Möglicherweise musst du den Zugriff auf Roblox Studio von Firewalls oder anderen Online-Sicherheitssoftware zulassen.

Problemlösungstipps

An diesem Punkt kannst du die Testserver nicht sehen, versuche eines der folgenden Optionen.

Wenn Sie Probleme mit dem Serverstart haben, überprüfen Sie den Artikel Feuerwalls- und Routerprobleme.
Setze die Anzahl der Spieler auf eine kleine Anzahl, wie 2 oder 3.
Wenn das Problem nicht gelöst wird, versuche, Studio neu zu starten oder deinen Computer neu zu starten.

Test auf dem lokalen Server

Sie werden mehrere Fenster sehen, wenn der Server startet. Jedes davon repräsentiert einen anderen Teil der Server/Client-Beziehung.

Server (grüne Grenze) führt das Spiel aus.
Client (blaue Grenzen) simuliert das Erlebnis eines Spieler:in.

Wenn der Server läuft, kannst du überprüfen, ob der Code funktioniert hat.

Finde das Server -Fenster mit dem grünen Rand.Überprüfen Sie die Druckausgabe, die aus dem Skript, das. PL: die Skriptsaufgerufen wird.Da es eine Wiederholungsschleife gibt, siehst du die gleichen Druckstatements wiederholen.
Sobald du die Tests abgeschlossen hast, schließe den Server im beliebigen Fenster mit der Schaltfläche Löschen.Dies schließt alle Server- und Client-Fenster und bringt dich zurück zu deinem normalen Studio-Fenster.

Problemlösungstipps

An dieser Stelle, wenn die beabsichtigten Druckstatements nicht erschienen, versuchen Sie eines der folgenden.

Überprüfe, dass Funktionen wie prepareGame() im Umfang der While-true-Schleife sind.
Wenn der Druck aus MatchManager nicht funktionierte, überprüfe einige allgemeine Fehlerbehebungen mit Modulskripten, wie sicherzustellen, dass das MatchManager-Skript in GameManager erforderlich ist oder dass prepareGame() dem Tisch des Moduls hinzugefügt wird.

Abgeschlossene Skripte

Im Folgenden sind abgeschlossene Skripte, um deine Arbeit zu überprüfen.

Skript, das. PL: die Skripts


-- Dienste
local ServerStorage = game:GetService("ServerStorage")
local Players = game:GetService("Players")

-- Modul-Skripte
local moduleScripts = ServerStorage:WaitForChild("ModuleScripts")
local matchManager = require(moduleScripts:WaitForChild("MatchManager"))
local gameSettings = require(moduleScripts:WaitForChild("GameSettings"))

-- Hauptspielschleife
while true do
	repeat
		print("Starting intermission")
		task.wait(gameSettings.intermissionDuration)
	until #Players:GetPlayers() >= gameSettings.minimumPlayers

	print("Intermission over")
	task.wait(gameSettings.transitionTime)

	matchManager.prepareGame()
end

Skript, das. PL: die Skripts


local MatchManager = {}

function MatchManager.prepareGame()
	print("Game starting!")
end

return MatchManager

Skript, das. PL: die Skripts


local GameSettings = {}

-- Spielvariablen
GameSettings.intermissionDuration = 5
GameSettings.roundDuration = 10
GameSettings.minimumPlayers = 2
GameSettings.transitionTime = 5

return GameSettings

Code die Spielschleife

Auf dieser Seite