Runden hinzufügen

Runden hinzufügen lässt dich das Spiel in Phasen mit einem klaren Start- und Zielpunkt strukturieren, damit Spieler ihren Fortschritt messen und regelmäßig die gleiche Spielchance haben können.Dies ist besonders wichtig für das teambasierte Spiel, weil es den Spielern die Möglichkeit bietet, ihren Spielstil abhängig von der Person in ihrem Team während dieser Runde zu wechseln.

Mit der Beispiel-Laser-Tag-Erfahrung als Referenz lehrt dieser Abschnitt des Tutorials Sie, wie Sie die integrierten Funktionen von Roblox verwenden und anpassen, um jede Runde zu strukturieren, einschließlich Skriptanleitungen für:

• Beginne eine Runde, indem du einzelne und teambezogene Punkte zurücksetzt und dann Spieler in ihre Team-Spawn-Zonen spawnen lässt.
• Anpassung von Variablen, die das Ziel für die Runde am oberen Rand des Bildschirms eines jeden Spieler:infestlegen.
• Verfolgung von Spielerpunktbeiträgen für den Teamscore.
• Auslösen einzigartiger Benutzeroberflächenbildschirme, abhängig davon, ob das Team des Spieler:indie Runde gewonnen oder verloren hat.
• Runde beenden, indem Spieler abgemeldet und in der neutralen Lobby platziert werden.

Nachdem du diesen Abschnitt abgeschlossen hast, wirst du lernen, wie du Blasterverhalten implementierst, das sowohl für Spieler genau als auch zufriedenstellend ist.

Schleife starten

ServerScriptService > Spielprozess > Runden > behandelt die meiste Logik für die Implementierung von Runden und beginnt, indem es die Funktion startRoundLoopAsync() aufruft, um den Beginn eines Rundenzyklus zu markieren.Während Spieler der Lobby beitreten und warten, um in ein Team aufgenommen zu werden, ruft startRoundLoopAsync() die resetScores() Funktion in ServerScriptService > Spiel > Bewertung > zurück, um sowohl die Rangliste als auch die Teampunkte zurückzusetzen.

Bewertung
function Scoring.resetScores()
	for _, player in Players:GetPlayers() do
		player.leaderstats.Points.Value = 0
	end

	for _, team in Teams:GetTeams() do
		team:SetAttribute(GuiAttribute.teamPoints, 0)
	end
end

Jetzt, da jeder bei Nullpunkten beginnt, setzt dann die Neutrale Spawn-Ort-Eigenschaft auf falsch , so dass nur Spieler mit der gleichen Eigenschaft wie der Spawn-Ort-Eigenschaft des Ortes spawnen können.Da die Eigenschaft des Spawnstandorts auf weiß statt auf die mint- oder karnationsrosa-Teams der Probe eingestellt ist, verhindert diese Konfiguration, dass alle Spieler dort spawnen oder respawnen, während eine Runde aktiv ist.

Für Spieler, die sich derzeit in der Lobby befinden, startRoundLoopAsync() überträgt alle Spieler, die sich derzeit innerhalb der Erfahrung befinden, auf die spawnPlayersInMap Funktion in ServerScriptService > Spiel > Runden > spawnPlayersInMap , um alle in ein Team mit ungefähr der gleichen Anzahl von Spielern zu sortieren und zu balancieren.

Für jede neue Spieler, die sich der Erfahrung anschließen, nachdem die Lobbygruppe in ein Team sortiert wurde, listet auf das Ereignis und ruft dann die Funktion erneut auf, um sie zum Team mit der geringsten Anzahl von Spielern hinzuzufügen.Für weitere Informationen zu diesem Prozess siehe Konfigurieren von Spawn-Standorten aus der vorherigen Spawnen und Respawnen Sektion des Tutorials.

Runden
-- Spawne alle Spieler auf der Karte
		neutralSpawn.Neutral = false
		spawnPlayersInMap(Players:GetPlayers())

		-- Spawne neue Spieler auf der Karte, wenn sie beitreten
		local playerAddedConnection = Players.PlayerAdded:Connect(function(player: Player)
			spawnPlayersInMap({ player })
		end)

Ziel festlegen

Jetzt, da jeder Spieler in der Arena mit seinen Teamkollegen ist, muss die Erfahrung Anweisungen liefern, was zu tun ist, um innerhalb der Runde erfolgreich zu sein.Die Probepunktlasertag-Erfahrung erfüllt diese Anforderung, indem sie eine objektive Aufforderung am oberen Rand des Bildschirms jedes Spieler:inmit klaren Anweisungen liefert, was das Team tun muss, um zu gewinnen.

Während Sie mehr darüber lernen können, wie Sie die Ziel-UI-Komponente konfigurieren und anzeigen im UI-Lehrplan, konzentriert sich dieser Abschnitt darauf, wie das Zielziel umgesetzt wird, wenn die Runde beginnt, beginnend damit, wie die Anzahl der Punkte festgelegt wird, die jedes Team benötigt, um die Runde abzuschließen.

Obwohl das Ziel prompt zur Laufzeit die Spieler informiert, dass sie drei Punkte erzielen müssen, um zu gewinnen, können Sie das Prompt in StarterGui > HUDGui untersuchen und sehen, dass es stattdessen einen konfigurierbaren " %d "-Wert für den Punktewert enthält.

"" %d " ist eine Platzhalterzeichen, die du jederzeit erhöhen oder verringern kannst, um deine eigenen Spielanforderungen zu erfüllen, indem du die Variable TEAM_SCORE_LIMIT in ReplicatedStorage > TEAM_SCORE_LIMIT aktualisierst.Wenn du zum Beispiel diese Zahl auf einen übermäßig hohen 200 festlegst, würden sich die Eingabeaufforderung und der Teampunkt entsprechend aktualisieren.

TEAM_SCORE_LIMIT
local TEAM_SCORE_LIMIT = 200 -- aktualisierte zeile, stelle sicher, dass du zurück

return TEAM_SCORE_LIMIT

Diese einfache Variablenaktualisierung funktioniert zur Laufzeit, weil sich, wenn die Runde beginnt, ReplicatedStorage > HUDGuiSetup > SetObjective > TEAM_SCORE_LIMIT Modulskript erfordert, damit es den Platzhaltertext im UI-Ziel-Objekt des TextLabel-Objekts austauschen kann.

TEAM_SCORE_LIMIT
local TEAM_SCORE_LIMIT = require(ReplicatedStorage.TEAM_SCORE_LIMIT)

local function setObjective(gui: ScreenGui)
	local bodyTextLabel = gui.Objective.ObjectiveDisplay.Body.BodyTextLabel
	bodyTextLabel.Text = bodyTextLabel.Text:format(TEAM_SCORE_LIMIT)
end

Schienpunkte

Jetzt, da die Spieler ein Ziel für die Runde haben, muss die Erfahrung die Punkte jedes Teams verfolgen, bis sie ihr Ziel erreichen.Während das Standardverhalten des Teams -Dienstes jeden Spieler automatisch unter seinem Team gruppiert und die Beiträge jedes Spieler:inzu seinem Teamscore addiert, ist es wichtig, Punkte in einer separaten Position zu speichern und zu überwachen, weil wenn ein Spieler punktet, dann vor dem Ende der Runde geht, werden seine Beiträge vom Bestenlisten entfernt, sobald sie sich vom Erlebnis abmelden.

Um sicherzustellen, dass dies nicht passiert und jeder Beitrag zum Teamziel erhalten bleibt, ReplicatedStorage > HUDGuiSetup > StartSyncingTeamPoints > speichert alle Punkte separat unter der Attribut teamPoints im Teams Service.Als teamPoints ruft dieses Modulskript die Funktion startSyncingTeamPoints auf, um den Teamzähler Class.GuiObjects innerhalb der Ziel-UI-Komponente zu finden.

Wenn es TeamACounter und TeamBCounter lokalisiert, erhält es deren teamColor, das mit den Team-Spawn-Zonen korreliert: TeamACounter zeigt die Punkte des grünen Teams an, und TeamBCounter verfolgt die Punkte des pinken Teams.

Starten der Synchronisierung von Teampunkten
local function startSyncingTeamPoints(gui: ScreenGui)
	for _, teamPointCounter in gui.Objective.TeamPointCounter:GetChildren() do
		if not teamPointCounter:IsA("GuiObject") then
			continue
		end

		local iconTeamColor = teamPointCounter:GetAttribute(GuiAttribute.teamColor)

Das Modulskript ruft dann seine Funktion auf, um zu überprüfen, dass die Attribut mint des TeamACounters und die Attribut carnation pink des TeamBCounters beide mit den entsprechenden Eigenschaften unter dem Service übereinstimmen.Wenn ja, gibt es beide Teams zurück.

Starten der Synchronisierung von Teampunkten
local function getTeamFromTeamColor(teamColor: Color3): Team?
	for _, team in Teams:GetTeams() do
		if team.TeamColor == teamColor then
			return team
		end
	end

	return nil
end

Wenn dies geschieht, startSyncingTeamPoints setzt die Objekte der beiden Teamzähler TextLabel auf ihre entsprechenden teamPoints Werte und aktualisiert sie, wenn ein Spieler einen Punkt erzielt, indem er einen anderen Spieler auf dem gegnerischen Team markiert.

Starten der Synchronisierung von Teampunkten
teamPointCounter.TextLabel.Text = team:GetAttribute(GuiAttribute.teamPoints)

		team:GetAttributeChangedSignal(GuiAttribute.teamPoints):Connect(function()
			teamPointCounter.TextLabel.Text = team:GetAttribute(GuiAttribute.teamPoints)

Alles in diesem Abschnitt hat sich bisher darauf konzentriert, wie man Punkte auf dem Bildschirm des Spieler:inverfolgt, aber es ist wichtig, die Logik zu überprüfen, die die Verfolgungspunkte auf dem Server handhabt, damit sie weiß, wann ein Team das Zielziel erreicht und die Runde gewinnt.Wenn du ServerScriptService > Gameplay > Bewertung besuchst, kannst du sehen, dass das Modulskript beginnt, indem es ein bindbares Ereignis erstellt, das jedes Mal abgefeuert wird, wenn ein Spieler einen Punkt erzielt.

Bewertung
local teamScoreChangedBindable = Instance.new("BindableEvent")

local Scoring = {
	teamScoreChanged = teamScoreChangedBindable.Event,
}

Dann ruft es die incrementScore-Funktion auf, die die folgenden Aktionen ausführt:

• Greift das Team des Spieler:inund seinen aktuellen Team-Punkte-Wert auf dem Team im Teams hinzu, fügt dann einen hinzu.
• Greift die individuelle Punktzahl des Spieler:inauf der Bestenlisteab und fügt eine hinzu.
• Feuert das zuvor erwähnte bindbare Ereignis mit dem Team des Spieler:inund dessen Punktzahl ab.

Dieser Prozess hält sowohl den Client als auch den Server effektiv im Einklang bezüglich der individuellen Punktzahlen der Spieler und der Team-Punktzahlen.

Bewertung
function Scoring.incrementScore(player: Player, amount: number)
	local team = player.Team
	assert(team, `Player {player.Name} must be on a team to score a point, but has no team`)

	local teamPoints = team:GetAttribute(GuiAttribute.teamPoints)
	teamPoints += amount
	team:SetAttribute(GuiAttribute.teamPoints, teamPoints)

	local leaderstat = player.leaderstats.Points
	leaderstat.Value += amount

	teamScoreChangedBindable:Fire(team, teamPoints)
end

Ergebnisse anzeigen

Wenn Spieler sich gegenseitig markieren und Punkte für ihr Team erzielen, überprüft ServerScriptService > Gameplay > Runden >, ob das Team, das gepunktet hat, das Rundenziel erfüllt hat.Wenn die Punktzahl ihres Teams niedriger als die Variable TEAM_SCORE_LIMIT in ReplicatedStorage > TEAM_SCORE_LIMIT ist, wartet der Server weiter, bis einer der Teams wieder punktet.

Sobald jedoch die Punktzahl eines Teams die TEAM_SCORE_LIMIT Variable erreicht, startet das Skript eine roundWinnerRemote Ereignisinstanz mit dem Namen des Spieler:inund seiner Mannschaft.

Runden
-- Überprüfe, ob die Runde nach jedem Ergebnis beendet ist
		local team: Team
		local score: number = 0

		while score < TEAM_SCORE_LIMIT do
			team, score = Scoring.teamScoreChanged:Wait()
		end

		-- Gewinner-Team anzeigen
		for _, player in Players:GetPlayers() do
			-- Versenden, auf welchem Team der Spieler am Ende der Runde ist
			-- weil das team des spieler:ingerade entfernt wird, also der client
			-- wird nicht in der lage sein, sein eigenes team zu überprüfen
			roundWinnerRemote:FireClient(player, team, player.Team)
		end

Das ReplicatedStorage > RoundResultsGuiSetup Skript auf jeder Client-Liste hört auf dieses roundWinnerRemote Ereignisinstanz, so dass es:

• Zeige einen einzigartigen StarterGui > RoundResultsGui UI-Bildschirm, der die Ergebnisse der Runde und ob der Spieler im siegreichen Team war ankündigt.
• Spiele einen Sieg oder eine Niederlage Audio-Clip.

Wenn zum Beispiel ein Spieler im Team ist, das den siegreichen Punkt erzielt hat, erhält er mehrere Formen von Feedback zu den Rundenergebnissen in Form eines UI-Bildschirms, der den Siegstext anzeigt, und eines Audio-Clips, der einen fröhlichen Klang wiedergibt.Umgekehrt, wenn ein Spieler nicht im Team ist, das den siegreichen Punkt erzielt hat, erhält er einen UI-Bildschirm, der Niederlagestext anzeigt, und einen Audioclip, der einen bedrohlichen Klang wiedergibt.

Rundenergebnis-GUI-Einstellung
local function onRoundWinner(winner: Team, localTeam: Team?)
	local victoryDefeatText = "Round ended!"
	if localTeam then
		-- Wenn unser Team gewinnt, zeigen wir Sieg! Ansonsten zeigen wir Niederlage an...
		local isVictory = winner == localTeam
		if isVictory then
			victorySound:Play()
			victoryDefeatText = VICTORY_TEXT
		else
			defeatSound:Play()
			victoryDefeatText = DEFEAT_TEXT
		end
	end

Teams zurücksetzen

Gleichzeitig überprüft ServerScriptService > Gameplay > Runden >, dass ein Team das Rundenziel erreicht und die entsprechende UI-Anzeige für jeden Spieler:inauslöst, indem es ihn von der Arena in die Lobby überträgt, indem es die Verbindung zu der Runde unterbricht.Dies startet den Prozess, die Runde formell zu beenden und beide Teams zurückzusetzen.

Durch die gleiche Logik in Spawnstandorte konfigurieren , Runden legt dann die Eigenschaft von neutralem Spawnstandort auf wahr fest, damit Spieler unabhängig von ihrem Statusdort spawnen können.Das bedeutet, dass die Lobby die einzige Position wird, an der Spieler spawnen können, nachdem sie von der Runde getrennt wurden.

Runden
-- Alle in die Lobby schicken
		playerAddedConnection:Disconnect()
		neutralSpawn.Neutral = true
		spawnPlayersInLobby(Players:GetPlayers())

Nach zehn Sekunden Wartezeit startet das Runden -Skript des Servers dann die Schleife erneut, indem es die Noten aller zurücksetzt und sie in neue Teams sortiert.Die Probe wiederholt diesen zyklischen Rundprozess erneut, bis es keine Spieler innerhalb des Servers gibt.

Jetzt, da Spieler mit ihrem eigenen Team auf die Karte spawnen und eine volle Runde spielen können, lehrt der nächste Abschnitt dich über die Skripte hinter dem Verhalten eines jeden Blasters.