Ajouter des manches

Ajouter des manches vous permet d'organiser le jeu en phases avec un point de départ et d'arrivée clairs afin que les joueurs puissent mesurer leur progression et avoir une opportunité régulière pour un champ de jeu égale. Ceci est particulièrement important pour le jeu basé sur l'équipe car il offre aux joueurs la possibilité de changer leur style de jeu en fonction de qui est sur leur équipe pendant cette manche.

En utilisant l'expérience de laser de test de génération comme référence, cette section du tutoriel vous apprend à utiliser et à personnaliser les fonctionnalités intégrées de Roblox pour structure chaque manche, y compris les conseils de script sur :

• Commencer une manche en réinitialisant les points individuels et d'équipe, puis en générant les joueurs dans leurs zones d'apparition d'équipe.
• Personnalisation des variables qui définissent l'objectif pour la manche en haut de l'écran de chaque joueur.
• Suivi des points de contribution du joueur pour leur score d'équipe.
• Activer des écrans d'interface utilisateur uniques en fonction de si l'équipe du joueur a gagné ou perdu la manche.
• Fini d'une manche en déconnectant les joueurs et en les faisant apparaître dans le lobby neutre.

Après avoir terminé cette section, vous apprendrez à implémenter le comportement du blaster qui est à la fois précis et satisfaisant pour les joueurs.

Démarrer la boucle

ServerScriptService > Gameplay > Rounds gère la plupart de la logique pour implémenter des rounds, et il commence par appeler la fonction

Score
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

Maintenant que tout le monde commence à partir de zéro points,

Pour les joueurs qui sont actuellement dans le lobby, startRoundLoopAsync() passe tous les joueurs actuellement dans l'expérience à la fonction spawnPlayersInMap dans ServerScriptService > 1> Gameplay1> > 4> Rounds4> > 7> spawnPlayersInMap7> pour trier et équilibrer tout

Pour les nouveaux joueurs qui rejoignent l'expérience après que le groupe du lobby ait trié dans une équipe, startRoundLoopAsync() liste l'événement Players.PlayerAdded:Connect , puis appelle la fonction spawnPlayersInMap pour les ajouter à l'équipe avec le

Les manches
-- Fais apparaître tous les joueurs sur la carte
		neutralSpawn.Neutral = false
		spawnPlayersInMap(Players:GetPlayers())

		-- Fais apparaître de nouveaux joueurs sur la carte lorsqu'ils rejoignent
		local playerAddedConnection = Players.PlayerAdded:Connect(function(player: Player)
			spawnPlayersInMap({ player })
		end)

Définir l'objectif

Maintenant que chaque joueur est dans l'arène avec ses coéquipiers, l'expérience doit fournir des instructions sur ce qu'il faut faire pour réussir dans la manche. L'expérience de laser tag de samuel aborde cette exigence en fournissant un prompt objectif au sommet de chaque joueur avec des instructions claires sur ce que l'équipe doit faire pour gagner.

Bien que vous puissiez en savoir plus sur la façon de configurer et d'afficher le objetif de l'interface utilisateur composant dans le Curriculum de l'UI, cette section se concentre sur la façon d'implémenter le but de l'objectif au fur et à mesure que la manche commence, en commençant par la façon dont chaque équipe doit terminer la manche.

Bien que la demande d'objectif au moment de l'exécution informe les joueurs qu'ils doivent marquer trois points pour gagner, si vous examinez la demande dans StarterGui > HUDGui , vous pouvez voir qu'il contient plutôt un configurable « %d » pour la valeur du point.

« %d » est une chaîne de placeholder que vous pouvez augmenter ou diminuer à tout moment pour remplir vos propres exigences de jeu en mettant à jour la variable TEAM_SCORE_LIMIT dans ReplicatedStorage > 1> TEAM_SCORE_LIMIT1>. Par exemple, si vous avez configuré ce nombre à un niveau excessivement

TEAM_SCORE_LIMIT
local TEAM_SCORE_LIMIT = 200 -- ligne mise à jour, assurez-vous de retour

return TEAM_SCORE_LIMIT

Cette simple mise à jour de variable fonctionne sur le temps d'exécution car, au début de la manche, ReplicatedStorage > HUDGuiSetup > SetObjective nécessite le script de module 1> TEAM_SCORE_LIMIT1> pour échanger la chaîne de placeholder dans l'objet de classe de l'4> Class.TextLabel4> objet.

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

Points de suivi

Maintenant que les joueurs ont un objectif pour la manche, l'expérience doit suivre le nombre de points de chaque équipe jusqu'à ce qu'ils atteignent leur objectif. Bien que le comportement par défaut du service Teams ajoute automatiquement chaque joueur sous leur équipe et ajoute le nombre de leurs contributions à leur score d'équipe, il est important de stocker et de suivre les points dans un

Pour vous assurer que cela ne se produise pas et que chaque contribution à l'objectif de l'équipe est préservée, ReplicatedStorage > HUDGuiSetup > StartSyncingTeamPoints stocke tous

Lorsqu'il localise TeamACounter et TeamBCounteur , il obtient leur attri- teamColor, qui se rapporte aux zones de génération de l'équipe : TeamACCounter affiche les points de l'équipe verte, et TeamBCCounter traque les points de l'équipe rose.

Démarrer le sincronisation de l'équipe
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)

Le script de module appelle alors sa fonction getTeamFromTeamColor pour valider que l'attribut teamColor de TeamACount et l'attribut teamColor de TeamBCount correspondent à l'attribut correspondant 2>Class.Team.Color2> sous le service 5>Class.Teams

Démarrer le sincronisation de l'équipe
local function getTeamFromTeamColor(teamColor: Color3): Team?
	for _, team in Teams:GetTeams() do
		if team.TeamColor == teamColor then
			return team
		end
	end

	return nil
end

Lorsque cela se produit, startSyncingTeamPoints met les objets TextLabel des deux comptoirs d'équipe sur leurs valeurs correspondantes teamPoints et continue de les mettre à jour chaque fois qu'un joueur marque un point en étiquetant un autre joueur sur l'équipe adverse.

Démarrer le sincronisation de l'équipe
teamPointCounter.TextLabel.Text = team:GetAttribute(GuiAttribute.teamPoints)

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

Tout dans cette section jusqu'à présent a été axé sur la façon de suivre les points sur l'écran du joueur, mais il est important de revoir la logique qui gère les points de suivi sur le serveur afin qu'elle sache quand une équipe atteint l'objectif de la manière la plus sûre et gagne la manche. Si vous revisitez ServerScriptService > Gameplay > Scoring

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

local Scoring = {
	teamScoreChanged = teamScoreChangedBindable.Event,
}

Il appelle ensuite la fonction incrementScore, qui effectue les actions suivantes :

• Prend le team de joueur et sa valeur actuelle de teamPoints dans l'objet Team dans le service Teams, puis ajoute un.
• Il prend le score individuel du joueur sur le tableau de bord et ajoute un.
• Lance l'événement lié précédemment avec l'équipe du joueur et leur score.

Ce processus maintient efficacement les clients et les serveurs en ligne quant aux scores individuels des joueurs et à leurs scores d'équipe.

Score
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

Afficher les résultats

Comme les joueurs se taguent les uns aux autres et marquent des points pour leur équipe, ServerScriptService > Gameplay > Rounds vérifie si l'équipe qui a marqué a atteint l'objectif de la manche. Si leur équipe est inférieure à la valeur variante de 1> TEAM_

Cependant, une fois que le score d'équipe atteint la variable TEAM_SCORE_LIMIT, le script déclenche une instance d'événement roundWinnerRemote avec le nom du joueur et son équipe.

Les manches
-- Vérifiez si la manche est terminée après chaque score
		local team: Team
		local score: number = 0

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

		-- Afficher l'équipe gagnante
		for _, player in Players:GetPlayers() do
			-- Envoyer quelle équipe le joueur est sur au bout de la manche
			-- parce que l'équipe du joueur est sur le point d'être supprimée, donc le client
			-- ne pourra pas vérifier son propre équipe
			roundWinnerRemote:FireClient(player, team, player.Team)
		end

Le script ReplicatedStorage > RoundResultsGuiSetup sur chaque client écoute cette instance d'événement roundWinnerRemote pour qu'elle puisse :

• Affichez un StarterGui > RoundResultsGui écran d'interface utilisateur qui annonce les résultats de la manche et si le joueur était sur l'équipe gagnante.
• Jouez un morceau audio de victoire ou de défaite.

Par exemple, si un joueur est dans l'équipe qui a marqué le point gagnant, il reçoit plusieurs formes de commentaires sur les résultats de la manche dans la forme d'un écran UI qui affiche le texte de victoire et d'un clip audio qui joue un son joyeux. Au contraire, si un joueur n'est pas dans l'équipe qui a marqué le point gagnant, il reçoit un écran UI qui affiche le texte de défaite et un clip audio qui joue un son ominieux.

RoundResultsGuiConfiguration
local function onRoundWinner(winner: Team, localTeam: Team?)
	local victoryDefeatText = "Round ended!"
	if localTeam then
		-- Si notre équipe a gagné, nous afficherons la victoire ! Sinon, affichez la défaite ...
		local isVictory = winner == localTeam
		if isVictory then
			victorySound:Play()
			victoryDefeatText = VICTORY_TEXT
		else
			defeatSound:Play()
			victoryDefeatText = DEFEAT_TEXT
		end
	end

Rechercher équipe

Au même moment que ServerScriptService > Gameplay > Rounds vérifie que une équipe a atteint l'objectif de la manche et déclenche l'affichage de l'interface utilisateur approprié pour chaque joueur, il transportera également tous les joueurs de l'arène dans le lobby en les déconnectant de la manche. Cela commence le processus de fin de la manche et réinitialise les deux équipes.

En utilisant la même logique dans Configurer les emplacements d'apparition, les manches puis définit la position d'apparition Neutre à la place de la location d'apparition 1> Class.SpawnLocation.Neutral|Neutre1> afin que les joueurs puissent y apparaître indépendamment de leur statut d'équipe. Cela

Les manches
-- Envoyez tout le monde dans le lobby
		playerAddedConnection:Disconnect()
		neutralSpawn.Neutral = true
		spawnPlayersInLobby(Players:GetPlayers())

Après avoir attendu dix secondes pour une intermission, le script du serveur Rounds démarre alors le boucle à nouveau en réinitialisant les scores de tout le monde et en les triant en nouvelles équipes. L'échantillon répète ce processus de boucle cyclique jusqu'à ce qu'il n'y ait pas de joueurs dans le serveur.

Maintenant que les joueurs peuvent apparaître dans la carte avec leur propre équipe et jouer un tour complet, la prochaine section vous apprend les scripts derrière le comportement de chaque blaster.