Aggiungi round

Aggiungere round ti consente di strutturare il gameplay in fasi con un punto di inizio e di fine chiaro in modo che i giocatori possano misurare i loro progressi e avere un'opportunità periodica per un campo di gioco uguale.Questo è particolarmente importante per il gameplay a squadre perché offre ai giocatori la possibilità di cambiare lo stile di gioco a seconda di chi è nella loro squadra durante quel round.

Usando l'esperienza di tag laser di esempio come riferimento, questa sezione del tutorial ti insegna come utilizzare e personalizzare le funzionalità integrate di Roblox per strutturare ogni round, inclusa la guida sugli script su:

• Iniziare un round ripristinando i punti individuali e di squadra, quindi generando giocatori nelle loro zone di spawn di squadra.
• Personalizzazione delle variabili che impostano l'obiettivo per il round nella parte superiore dello schermo di ciascun Giocatore.
• Contributi puntuali del giocatore per il punteggio della loro squadra.
• Attivazione di schermi UI unici a seconda se la squadra del Giocatoreabbia vinto o perso la partita.
• Terminare un round disconnettendo i giocatori e generandoli nella lobby neutra.

Dopo aver completato questa sezione, imparerai a implementare il comportamento del blaster che sia sia preciso che soddisfacente per i giocatori.

Inizia il ciclo

ServerScriptService > Gameplay > Rounds gestisce la maggior parte della logica per implementare le partite e inizia chiamando la funzione startRoundLoopAsync() per segnare l'inizio di un ciclo di partite.Mentre i giocatori si uniscono alla lobby e attendono di essere assegnati a una team, chiama la funzione in ServerScriptService > Gameplay > Punti di squadra > per ripristinare sia la classifica che i punti della squadra.

Valutazione
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

Ora che tutti stanno partendo da punti zero, poi imposta la proprietà Neutral della posizione di spawn a falso in modo che solo i giocatori con la stessa proprietà della posizione di spawn possano apparire lì.Poiché la proprietà Luogo rigenerazionedi TeamColor è impostata su bianco invece delle squadre di menta o carnation rosa del campione, questa configurazione impedisce a tutti i giocatori di generare o rigenerare lì mentre una partita è attiva.

Per i giocatori che sono attualmente nella lobby, startRoundLoopAsync() passa tutti i giocatori attualmente all'interno dell'esperienza alla funzione spawnPlayersInMap in ServerScriptService > Gameplay > Rounds > spawnPlayersInMap per ordinare e bilanciare tutti in una squadra con circa lo stesso numero di giocatori.

Per tutti i nuovi giocatori che si uniscono all'esperienza dopo che il gruppo della lobby è stato ordinato in una team, startRoundLoopAsync() ascolta l'evento Players.PlayerAdded:Connect e chiama nuovamente la funzione spawnPlayersInMap per aggiungerli alla squadra con la minore quantità di giocatori.Per ulteriori informazioni su questo processo, vedi Configura le posizioni di spawn dalla precedente sezione Spawning e Respawning del Tutoriale.

Turni
-- Genera tutti i giocatori sulla mappa
		neutralSpawn.Neutral = false
		spawnPlayersInMap(Players:GetPlayers())

		-- Genera nuovi giocatori sulla mappa quando si uniscono
		local playerAddedConnection = Players.PlayerAdded:Connect(function(player: Player)
			spawnPlayersInMap({ player })
		end)

Imposta obiettivo

Ora che ogni giocatore è nell'arena con i compagni di squadra, l'esperienza deve fornire istruzioni su cosa fare per avere successo all'interno del round.L'esperienza di tag laser di esempio affronta questo requisito fornendo un prompt obiettivo nella parte superiore dello schermo di ciascun Giocatorecon istruzioni chiare su ciò che la squadra deve fare per vincere.

Mentre puoi imparare di più su come configurare e visualizzare il componente Interfaccia utente obiettivo nell'interfaccia utente, questa sezione si concentra su come implementare l'obiettivo del goal mentre inizia la partita, iniziando con il modo in cui impostare la quantità di punti di cui ogni team ha bisogno per completare la partita.

Anche se l'invito all'obiettivo durante l'esecuzione informa i giocatori che devono segnare tre punti per vincere, se esamini l'invito in StarterGui > HUDGui , puoi vedere che contiene invece un configurabile " %d " per il valore del punto.

"" %d "è una stringa segnaposto che puoi aumentare o diminuire in qualsiasi momento per soddisfare le tue esigenze di gioco aggiornando la variabile TEAM_SCORE_LIMIT in ReplicatedStorage > TEAM_SCORE_LIMIT .Ad esempio, se impostassi questo numero a un livello eccessivamente elevato 200, il contapassi del prompt e del team si aggiornerà di conseguenza.

TEAM_SCORE_LIMIT
local TEAM_SCORE_LIMIT = 200 -- linea aggiornata, assicurati di tornare indietro

return TEAM_SCORE_LIMIT

Questo semplice aggiornamento della variabile funziona in tempo esecuzione perché quando inizia la partita, ReplicatedStorage > HUDGuiSetup > SetObjective richiede lo script del modulo per poter sostituire la stringa di riempimento nell'oggetto dell'obiettivo dell'interfaccia utente.

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

Punti di traccia

Ora che i giocatori hanno un obiettivo per il round, l'esperienza deve tenere traccia dei punti di ogni teamfino a quando non raggiungono il loro obiettivo.Mentre il comportamento predefinito del servizio Teams gruppa automaticamente ogni giocatore sotto la loro squadra e aggiunge le contribuzioni di ogni Giocatorealla loro punteggio di squadra, è importante archiviare e monitorare i punti in una posizione separata per il gioco a round-based perché se un giocatore segna poi se ne va prima che la partita finisca, le sue contribuzioni vengono dedotte dalla classifica non appena si disconnettono dall'esperienza.

Per garantire che ciò non accada e che ogni contributo verso l'obiettivo della squadra sia preservato, ReplicatedStorage > HUDGuiSetup > StartSyncingTeamPoints > memorizza tutti i punti separatamente sotto l'attributo in servizio.Come teamPoints incrementi, questo script del modulo chiama la funzione startSyncingTeamPoints per trovare il contapassi del team Class.GuiObjects all'interno della componente dell'interfaccia utente obiettivo.

Quando localizza TeamACounter e TeamBCounter , ottiene il loro attributo teamColor, che corrisponde alle zone di spawn del team verde: TeamACounter mostra i punti del team verde e TeamBCounter traccia i punti del team rosa.

Inizia a sincronizzare i punti del team
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)

Lo script del modulo chiama quindi la sua funzione di validazione per confermare che l'attributo menta di TeamACounter e l'attributo carnazione rosa di TeamBCounter corrispondono alle rispettive proprietà sotto il servizio.Se è così, restituisce entrambe le squadre.

Inizia a sincronizzare i punti del team
local function getTeamFromTeamColor(teamColor: Color3): Team?
	for _, team in Teams:GetTeams() do
		if team.TeamColor == teamColor then
			return team
		end
	end

	return nil
end

Quando ciò accade, startSyncingTeamPoints imposta gli oggetti di entrambi i contatori di squadra TextLabel ai loro rispettivi valori teamPoints, e continua ad aggiornarli ogni volta che un giocatore segna un punto marcando un altro giocatore della teamopposta.

Inizia a sincronizzare i punti del team
teamPointCounter.TextLabel.Text = team:GetAttribute(GuiAttribute.teamPoints)

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

Tutto in questa sezione finora si è concentrato su come tracciare i punti sullo schermo del Giocatore, ma è importante rivedere la logica che gestisce i punti di tracciamento sul server in modo che sappia quando una squadra raggiunge l'obiettivo e vince la partita.Se rivisiti ServerScriptService > Gameplay > Scoring , puoi vedere che lo script del modulo inizia creando un evento bindable, che verrà attivato ogni volta che un giocatore segna un punto.

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

local Scoring = {
	teamScoreChanged = teamScoreChangedBindable.Event,
}

Quindi chiama la funzione incrementScore, che esegue le seguenti azioni:

• Afferra il team del Giocatoree il loro attuale valore di punti squadra sull'oggetto Team nel servizio Teams, quindi aggiunge uno.
• Cattura il punteggio individuale del Giocatoresulla Classificae aggiunge uno.
• Fuoca l'evento bindable precedentemente menzionato con sia la squadra del Giocatoreche il loro punteggio.

Questo processo mantiene efficacemente sia il client che il server allineati rispetto alle singole valutazioni dei giocatori e alle valutazioni della squadra.

Valutazione
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

Mostra risultati

Mentre i giocatori si etichettano l'un l'altro e segnano punti per la loro team, ServerScriptService > Gameplay > Round controlla se la squadra che ha segnato ha raggiunto l'obiettivo del round.Se il punteggio della squadra è inferiore alla variabile TEAM_SCORE_LIMIT in ReplicatedStorage > TEAM_SCORE_LIMIT , il server continua ad aspettare fino a quando una delle squadre non segna di nuovo.

Tuttavia, una volta che il punteggio di una teamraggiunge la variabile TEAM_SCORE_LIMIT, lo script lancia un'istanza di evento roundWinnerRemote con il nome del Giocatoree la sua team.

Turni
-- Controlla se la partita è finita dopo ogni punteggio
		local team: Team
		local score: number = 0

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

		-- Mostra la teamvincitrice
		for _, player in Players:GetPlayers() do
			-- Invio di quale squadra il giocatore è alla fine del round
			-- perché la squadra del giocatoreè about to essere rimossa, quindi il client
			-- non sarà in grado di controllare la propria team
			roundWinnerRemote:FireClient(player, team, player.Team)
		end

Lo script ReplicatedStorage > RoundResultsGuiSetup su ogni elenco client ascolta questo evento roundWinnerRemote in modo che possa:

• Mostra uno schermo UI unico StarterGui > RoundResultsGui che annuncia i risultati del round e se il giocatore era nella teamvincitrice.
• Riproduci un'audio clip di vittoria o sconfitta.

Ad esempio, se un giocatore è nella squadra che ha segnato il punto vincente, riceve molte forme di feedback sui risultati del round sotto forma di una schermata dell'interfaccia utente che mostra il testo della vittoria e un audio che riproduce un suono gioioso.Al contrario, se un giocatore non è nella squadra che ha segnato il punto vittorioso, riceve uno schermo UI che mostra il testo della sconfitta e un audio clip che riproduce un suono minaccioso.

Configurazione di RoundResultsGui
local function onRoundWinner(winner: Team, localTeam: Team?)
	local victoryDefeatText = "Round ended!"
	if localTeam then
		-- Se la nostra squadra vince, mostreremo la Vittoria! Altrimenti mostreremo la Sconfitta...
		local isVictory = winner == localTeam
		if isVictory then
			victorySound:Play()
			victoryDefeatText = VICTORY_TEXT
		else
			defeatSound:Play()
			victoryDefeatText = DEFEAT_TEXT
		end
	end

Ripristina squadre

Allo stesso tempo che ServerScriptService > Gameplay > Round verifica che una squadra abbia raggiunto l'obiettivo della partita e attivi la visualizzazione dell'interfaccia utente appropriata per ogni Giocatore, trasporta anche tutti i giocatori dall'arena alla lobby disconnettendoli dalla partita.Questo inizia il processo di terminazione formale del round e del ripristino di entrambe le squadre.

Usando la stessa logica in Configura le posizioni di spawn, Rounds poi imposta la proprietà Neutral della posizione di spawn Neutral a vero in modo che i giocatori possano spawnare lì indipendentemente dal loro Statodi squadra.Questo significa che la lobby diventa l'unica posizione in cui i giocatori possono spawnare dopo essere stati disconnessi dalla partita.

Turni
-- Invia tutti alla lobby
		playerAddedConnection:Disconnect()
		neutralSpawn.Neutral = true
		spawnPlayersInLobby(Players:GetPlayers())

Dopo aver aspettato dieci secondi per un'interruzione, lo script del server Rounds inizia quindi il ciclo di nuovo ripristinando le punteggi di tutti e classificandoli in nuove squadre.L'esempio ripete di nuovo questo ciclico processo round fino a quando non ci sono alcun giocatore all'interno del Server.

Ora che i giocatori possono spawnarsi sulla mappa con la propria squadra e giocare un round completo, la sezione successiva ti insegna sugli script dietro il comportamento di ogni blaster.