Añadir Rondas

Agregar rondas te permite estructurar el juego en fases con un punto de inicio y final claro para que los jugadores puedan medir su progreso y tengan una oportunidad periódica para un campo de juego igualitario. Esto es particularmente importante para el juego basado en equipos, ya que ofrece a los jugadores la oportunidad de cambiar su estilo de juego dependiendo de quién esté en su equipo durante esa ronda.

Usando la experiencia de etiqueta láser ejemplo como referencia, esta sección del tutorial te enseña cómo usar y personalizar las características integradas de Roblox para estructurar cada ronda, incluida la guía de scripts sobre:

• Comenzar una ronda restableciendo los puntos individuales y de equipo, luego generando jugadores en sus zonas de spawn.
• Personalizar variables que establecen el objetivo para la ronda en la parte superior de la pantalla de cada jugador.
• Rastrear contribuciones de puntos del jugador para su puntaje de equipo.
• Activar pantallas de UI únicas dependiendo de si el equipo del jugador ganó o perdió la ronda.
• Finalizando una ronda desconectando a los jugadores y generándolos en el lobby neutral.

Después de completar esta sección, aprenderás a implementar el comportamiento de los láseres que es tanto preciso como satisfactorio para los jugadores.

Iniciar Loop

Servicio deScript del Servidor > Gameplay > Rounds manejos de la mayoría de la lógica para implementar rondas, y comienza llamando la fun

Calificación
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

Ahora que todos están comenzando con puntos cero,

Para los jugadores que están actualmente en el lobby, startRoundLoopAsync() pasa a todos los jugadores actualmente dentro de la experiencia a la función spawnPlayersInMap en ServerScriptService > 1> Gameplay1> > 4> Rounds4> > 7> spawnPlayersInMap7> para ordenar y equilibrar a

Para cualquier nuevo jugador que se una a la experiencia después de que el grupo del lobby fue clasificado en un equipo, startRoundLoopAsync() escucha el evento Players.PlayerAdded:Connect y luego llama a la función spawnPlayersInMap para agregarlos al equipo con la menor

Rondas
-- Genera todos los jugadores en el mapa
		neutralSpawn.Neutral = false
		spawnPlayersInMap(Players:GetPlayers())

		-- Genera nuevos jugadores en el mapa cuando se unan
		local playerAddedConnection = Players.PlayerAdded:Connect(function(player: Player)
			spawnPlayersInMap({ player })
		end)

Establecer Objetivo

Ahora que cada jugador está en la arena con sus compañeros de equipo, la experiencia necesita proporcionar instrucciones sobre qué hacer para tener éxito dentro de la ronda. La experiencia de samurái láser proporciona este requisito al proporcionar una solicitud de objetivo en la parte superior de cada jugador con instrucciones claras sobre lo que el equipo necesita hacer para ganar.

Mientras puede aprender más sobre cómo configurar y mostrar el objetivo de la interfaz de usuario componente en el Currículo de UI, esta sección se enfoca en cómo implementar el objetivo de la meta a medida que la ronda comienza, comenzando con cómo configurar la cantidad de puntos que cada equipo necesita completar la ronda.

A pesar de que la solicitud de objetivo en tiempo de ejecución informa a los jugadores que necesitan anotar tres puntos para ganar, si examinas la solicitud en StarterGui > HUDGui , puedes ver que en realidad contiene un configurable " %d " para el valor de puntos.

" %d " es una cadena de lugar placeholder que puedes aumentar o disminuir en cualquier momento para cumplir con tus propias exigencias de juego actualizando la variable TEAM_SCORE_LIMIT en ReplicatedStorage > 1> TEAM_SCORE_LIMIT1> . Por ejemplo, si tú hubieras est

LÍMITE DE PUNTUACIÓN DE EQUIPO
local TEAM_SCORE_LIMIT = 200 -- línea actualizada, asegúrese de cambiar de volver

return TEAM_SCORE_LIMIT

Esta simple actualización de variable funciona en el tiempo de ejecución porque a medida que la ronda comienza, ReplicatedStorage > HUDGuiSetup > SetObjective > 1> TEAM_SCORE_LIMIT1> requiere que el script del módulo 4> Class.TextLabel4> para intercambiar la cadena de reemplazo en el objeto de objetivo de la interfaz de

LÍMITE DE PUNTUACIÓN DE EQUIPO
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

Puntos de pista

Ahora que los jugadores tienen un objetivo para la ronda, la experiencia necesita seguir el puntaje de cada equipo hasta que se cumpla su objetivo. Mientras que el servicio Teams por defecto debe agrupar a cada jugador debajo de su equipo y agregar el puntaje de cada jugador a su puntaje de equipo, es importante almacenar y monitorear los puntos en una ubic

Para asegurar que esto no suceda y cada contribución hacia el objetivo del equipo se conserve, ReplicatedStorage > HUDGuiSetup > StartSyncingTeamPoints almacena todos los puntos separ

Cuando localiza TeamACounter y TeamBCount , obtiene su atributo teamColor, que se relaciona con las zonas de generación de equipos: TeamACCounter muestra los puntos del equipo verde, y TeamBCount muestra los puntos del equipo rosa.

Comenzar a sincronizar los puntos de equipo
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)

El script del módulo luego llama su función getTeamFromTeamColor para validar que el atributo mint de TeamACount y el atributo teamColor de TeamBCount coinciden con las propiedades correspondientes 2>Class.Team.Color2> debajo del servicio 5>

Comenzar a sincronizar los puntos de equipo
local function getTeamFromTeamColor(teamColor: Color3): Team?
	for _, team in Teams:GetTeams() do
		if team.TeamColor == teamColor then
			return team
		end
	end

	return nil
end

Cuando esto ocurre, startSyncingTeamPoints establece los objetos TextLabel de ambos contadores de equipo a sus valores de teamPoints correspondientes, y continúa actualizándolos siempre que un jugador marque un punto al etiquetar a otro jugador en el equipo opuesto.

Comenzar a sincronizar los puntos de equipo
teamPointCounter.TextLabel.Text = team:GetAttribute(GuiAttribute.teamPoints)

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

Todo en esta sección hasta ahora se ha centrado en cómo rastrear los puntos en la pantalla del jugador, pero es importante revisar la lógica que maneja los puntos de rastreo en el servidor para que sepa cuando un equipo alcanza el objetivo y gana la ronda. Si vuelve a visitar ServerScriptService > Gameplay > Scoring , puede ver que

Calificación
local teamScoreChangedBindable = Instance.new("BindableEvent")

local Scoring = {
	teamScoreChanged = teamScoreChangedBindable.Event,
}

Luego llama la función incrementScore, que realiza las siguientes acciones:

• Agarrar el equipo del jugador y su valor actual de Equipo en el objeto Team en el servicio Teams, luego agrega uno.
• Obtiene el puntaje individual del jugador en la tabla de clasificación y lo agrega.
• Dispara el evento vinculable anterior con tanto el equipo del jugador como su puntaje.

Este proceso mantiene efectivamente tanto al cliente como al servidor alineados con respecto a las puntuaciones individuales de los jugadores y sus puntuaciones de equipo.

Calificación
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

Mostrar los resultados

A medida que los jugadores etiquetan uno al otro y obtienen puntos de su equipo, ServerScriptService > Gameplay > Rounds > 1> Comprobaciones de ronda1> > si su equipo obtuvo el objetivo de la ronda. Si su equipo obtiene un puntaje inferior al TEAM_SCORE_LIMIT variable

Sin embargo, una vez que la puntuación de un equipo alcanza la variable TEAM_SCORE_LIMIT, el script activa una instancia de evento roundWinnerRemote con el nombre del jugador y su equipo.

Rondas
-- Asegúrese de que la ronda haya terminado después de cada puntuación
		local team: Team
		local score: number = 0

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

		-- Mostrar equipo ganador
		for _, player in Players:GetPlayers() do
			-- Enviar qué equipo tiene el jugador al final de la ronda
			-- porque el equipo del jugador está a punto de ser eliminado, por lo que el cliente
			-- no podrá verificar su propio equipo
			roundWinnerRemote:FireClient(player, team, player.Team)
		end

El script ReplicatedStorage > RoundResultsGuiSetup en cada lista de clientes escucha para este evento roundWinnerRemote para que pueda:

• Muestra una pantalla de StarterGui > RoundResultsGui que anuncia los resultados de la ronda y si el jugador estaba en el equipo ganador.
• Reproduce un audio de victoria o derrota.

Por ejemplo, si un jugador está en el equipo que anotó el punto ganador, reciben múltiples formas de retroalimentación en los resultados de la ronda en forma de una pantalla de UI que muestra el texto de la victoria y un clip de audio que reproduce un sonido alegre. Por lo contrario, si un jugador no está en el equipo que anotó el punto ganador, reciben una pantalla de UI que muestra el texto de la derrota y un clip de audio que reproduce un sonido alegre.

RoundResultsGuiConfiguración
local function onRoundWinner(winner: Team, localTeam: Team?)
	local victoryDefeatText = "Round ended!"
	if localTeam then
		-- Si nuestro equipo gana, ¡mostraremos Victoria! De lo contrario, mostraremos Derrota...
		local isVictory = winner == localTeam
		if isVictory then
			victorySound:Play()
			victoryDefeatText = VICTORY_TEXT
		else
			defeatSound:Play()
			victoryDefeatText = DEFEAT_TEXT
		end
	end

Restablecer equipos

Al mismo tiempo que Servicio de Script del Servidor > Juego en línea > Rondas verifica que un equipo ha alcanzado el objetivo de la ronda y activa la pantalla de UI apropiada para cada jugador, también transporta a todos los jugadores desde la arena a la sala de espera desconectándolos de la ronda. Esto comienza el proceso de finalizar la ronda y restablecer ambos equipos.

Usando la misma lógica en Configurar ubicaciones de spawn, Rounds y luego establece la propiedad Neutral de la ubicación de spawn de 1> Class.SpawnLocation.Neutral|Neutral1> para establecer que los jugadores puedan generar allí sin importar su estado de equipo. Esto significa que el lobby se convierte en la única ubicación

Rondas
-- Enviar a todos a la sala de espera
		playerAddedConnection:Disconnect()
		neutralSpawn.Neutral = true
		spawnPlayersInLobby(Players:GetPlayers())

Después de esperar diez segundos para un intermedio, el script del servidor Rounds entonces comienza el ciclo de nuevo al restablecer las puntuaciones de todos y colocarlas en nuevos equipos. La muestra repite este proceso de ciclo循 hasta que no haya ningún jugador dentro del servidor.

Ahora que los jugadores pueden desplegarse en el mapa con su propio equipo y jugar una ronda completa, la siguiente sección te enseña sobre los scripts detrás del comportamiento de cada blaster.