Adicionando Rounds

Adicionar rodadas permite que você estruture o jogo em fases com um ponto de início e término claro para que os jogadores possam medir seu progresso e ter uma oportunidade periódica de um campo de jogo igual. Isso é particularmente importante para o jogo baseado em equipe porque oferece aos jogadores a chance de alternar seu estilo de jogo dependendo de quem estiver em seu time durante essa rodada.

Usando a experiência de laser de exemplo noivo como referência, esta seção do tutorial ensina você a usar e personalizar os recursos incorporados do Roblox para estruturar cada rodada, incluindo orientações de script em:

• Começando uma rodada ao redefinir pontos individuais e de equipe, então gerar jogadores para suas zonas de spawn.
• Personalizar variáveis que definem o objetivo para a rodada no topo da tela de cada jogador.
• Rastreamento de contribuições de pontos do jogador para a pontuação da equipe.
• Gatilhando telas de UI exclusivas dependendo se a equipe do jogador ganhou ou perdeu a rodada.
• Terminando uma rodada desconectando os jogadores e gerando-os na sala neutral.

Depois de completar esta seção, você aprenderá a implementar comportamento de arma que seja preciso e satisfatório para os jogadores.

Iniciar Loop

ServerScriptService > Gameplay > Rounds > 0> startRoundLoopAsync()0> > 3> set

Pontuação
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

Agora que todos estão começando em pontos zero,

Para jogadores que estão atualmente no lobby, startRoundLoopAsync() passes todos os jogadores atualmente dentro da experiência para a função spawnPlayersInMap em ServerScriptService > 1>Gameplay1> > 4>Rounds4> > 7>são7> sortar e balancear todos em uma equipe com aproximadamente o

Para qualquer novo jogador que se juntar à experiência depois que o grupo do lobby foi classificado em uma Equipe, startRoundLoopAsync() ouve o evento Players.PlayerAdded:Connect, e em seguida chama a função spawnPlayersInMap novamente para adicioná-los à

Rounds
-- Gerar todos os jogadores no mapa
		neutralSpawn.Neutral = false
		spawnPlayersInMap(Players:GetPlayers())

		-- Gerar novos jogadores no mapa quando eles se juntarem
		local playerAddedConnection = Players.PlayerAdded:Connect(function(player: Player)
			spawnPlayersInMap({ player })
		end)

Definir Objetivo

Agora que cada jogador está na arena com seus colegas de equipe, a experiência precisa fornecer instruções sobre o que fazer para ter sucesso dentro da rodada. A experiência de laser de exemplo aborda essa exigência fornecendo uma solicitação objetiva na parte superior da tela de cada jogador com orientações claras sobre o que a equipe precisa fazer para vencer.

Enquanto você pode aprender mais sobre como configurar e exibir o Objetivo UI componente na UI Curriculum, esta seção foca em como implementar o objetivo de objetivo como a rodada começa, começando com como definir a quantidade de pontos que cada equipe precisa completar a rodada.

Embora o prompt de objetivo na execução informe os jogadores que precisam marcar três pontos para ganhar, se você examinar o prompt em StarterGui > HUDGui , você pode ver que ele contém em vez disso um configurável " %d " para o valor de ponto.

“%d%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20

TEAM_SCORE_LIMIT
local TEAM_SCORE_LIMIT = 200 -- linha atualizada, certifique-se de mudar de voltar

return TEAM_SCORE_LIMIT

Essa simples atualização de variável funciona no tempo de execução porque, à medida que a rodada começa, ReplicatedStorage > HUDGuiSetup > DefinirObjetivo > 2>SetObjective2> requer o script de módulo 5> TEAM_SCORE_LIMIT5> para que possa trocar a string de espaço reservado na classe de Objeto8>

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

Pontos de rastro

Agora que os jogadores têm um objetivo para a rodada, a experiência precisa acompanhar cada ponto de cada Equipeaté que eles atinjam seu objetivo. Embora o comportamento padrão do serviço Teams ajude a agrupar cada jogador abaixo de sua equipe e adicionar cada contribuição de cada jogador à sua pontuação de equipe, é importante arma

Para garantir que isso não aconteça e que cada contribuição para o objetivo da equipe seja preservada, Armazenamento Replicado > Configuração HUD > Iniciar sincroniz

Quando localiza TeamACounter e TeamBCount , ele recebe seu atributo teamColor, que se relaciona com as zonas de spawn de equipes: TeamACCounter exibe os pontos do Equipeverde e TeamBCount rastreia os pontos do Equiperosa.

Começar Sincronizando Equipe
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)

O script de módulo então chama sua função getTeamFromTeamColor para validar que o atributo TeamCounter de sua teamColor 2>teamColor2> atributo e o atributo 5>TeamBCounter5> de sua 8>teamColor</

Começar Sincronizando Equipe
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 isso ocorre, startSyncingTeamPoints configura ambos os objetos de classe de ambos os contadores de ambas as equipes para seus valores de equipe correspondentes TextLabel e continua atualizando-os sempre que um jogador marcar outro jogador for fora na Equipeoposta.

Começar Sincronizando Equipe
teamPointCounter.TextLabel.Text = team:GetAttribute(GuiAttribute.teamPoints)

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

Tudo nesta seção até agora se concentrou em como rastrear pontos na tela do jogador, mas é importante revisar a lógica que processa pontos de rastreamento no servidor para que saiba quando uma equipe atinge o objetivo final e ganha a rodada. Se você revisar ServerScriptService > Gameplay > Scoring , você pode ver que o script de mód

Pontuação
local teamScoreChangedBindable = Instance.new("BindableEvent")

local Scoring = {
	teamScoreChanged = teamScoreChangedBindable.Event,
}

Em seguida, chama a função incrementScore, que executa as seguintes ações:

• Pega o time do jogador e seu valor de equipe atual em um objeto Team no serviço Teams, então adiciona um.
• Pega o score individual do jogador na tabela de classificação e adiciona um.
• Dispara o evento vinculado anteriormente com o time do jogador e sua pontuação.

Esse processo mantém efetivamente ambos o cliente e o servidor alinhados em relação a ambas as pontuações dos jogadores e suas pontuações de equipe.

Pontuação
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

Exibindo Resultados

À medida que os jogadores se marcam e ganham pontos para sua Equipe, ServerScriptService > Gameplay > Rounds verifica se a equipe que marcou atingiu o objetivo da rodada. Se a equipe deles for menor que a variável 1> TEAM_SCORE_LIMIT1> em <

No entanto, uma vez que a pontuação de uma Equipeatinge a variável TEAM_SCORE_LIMIT, o script firea uma instância de evento roundWinnerRemote com o nome do jogador e seu Equipe.

Rounds
-- Verifique se a rodada terminou após cada pontuação
		local team: Team
		local score: number = 0

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

		-- Exibir Equipevencedora
		for _, player in Players:GetPlayers() do
			-- Enviar o time que o jogador está em no final da rodada
			-- porque a equipe do jogador está prestes a ser removida, então o cliente
			-- não será capaz de verificar sua própria equipe
			roundWinnerRemote:FireClient(player, team, player.Team)
		end

O ReplicatedStorage > RoundResultsGuiSetup script em cada lista de clientes ouve este roundWinnerRemote evento para que possa:

• Exibe uma tela de StarterGui > RoundResultsGui que anuncia os resultados da rodada e, se o jogador estiver na Equipevencedora.
• Jogue um áudio de vitória ou derrote.

Por exemplo, se um jogador estiver na equipe que marcou o ponto vencedor, eles recebem várias formas de feedback sobre os resultados da rodada na forma de uma tela de UI que exibe o texto de vitoria e um áudio que toca um som alegre. Conversamente, se um jogador não estiver na equipe que marcou o ponto vencedor, eles recebem uma tela de UI que exibe o texto de derrota, e um áudio que toca um som alegre.

Configuração de RoundResultsGui
local function onRoundWinner(winner: Team, localTeam: Team?)
	local victoryDefeatText = "Round ended!"
	if localTeam then
		-- Se nossa equipe ganhar, exibiremos Vitória! Caso contrário, exibiremos Derrota...
		local isVictory = winner == localTeam
		if isVictory then
			victorySound:Play()
			victoryDefeatText = VICTORY_TEXT
		else
			defeatSound:Play()
			victoryDefeatText = DEFEAT_TEXT
		end
	end

Redefinir Equipes

Na mesma hora que ServerScriptService > Jogabilidade > Rounds verifica que uma equipe atingiu o objetivo da rodada e inicia a exibição de UI apropriada para cada jogador, também transporta todos os jogadores da arena para o lobby desconectando-os da rodada. Isso inicia o processo de encerrar a rodada e redefinir ambas as equipes.

Usando a mesma lógica em Configurar Locais de Spawn, Rounds e depois configura a propriedade Neutro da localização de spawn para 1> Class.SpawnLocation.Neutral|Neutral1> para que os jogadores possam gerar lá, independentemente do status de sua equipe. Isso significa que o lobby se torna o único

Rounds
-- Mande todos para o lobby
		playerAddedConnection:Disconnect()
		neutralSpawn.Neutral = true
		spawnPlayersInLobby(Players:GetPlayers())

Depois de esperar dez segundos por um intermissão, o Rounds script do servidor então começa o loop de novo ao redefinir as pontuações de todos e colocá-las em novas equipes. O exemplo repete esse processo de round cíclico até que não haja nenhum jogador dentro do servidor.

Agora que os jogadores podem spawnar no mapa com sua própria equipe e jogar uma rodada completa, a próxima seção ensina você sobre os scripts por trás do comportamento de cada blaster.