Puntos de Calificación | Documentación del Centro de creación de Roblox

En los tutoriales anteriores, hiciste una variedad de características de experiencia, incluyendo plataformas desapariciendo y lava mortal. Este tutorial los une en una experiencia jugable donde los usuarios ven quién puede quedarse con vida más tiempo. Cada segundo que sobreviven, se agregará un punto a su puntaje.

Configurando

Primero, tendrás que configurar la escena para tu experiencia. Duplica las plataformas desapariciendo que hiciste en el tutorial anterior y deja que los usuarios compitan para quedarse en el tablero de plataformas durante el mayor tiempo posible.

También puedes usar lava mortal para matar a los usuarios cuando se caigan de las plataformas, o simplemente déjalos caer para que terminen en su perdición. Asegúrate de colocar un SpawnLocation en alguna parte donde los usuarios puedan saltar a las plataformas para comenzar a jugar.

Puntos del jugador

Roblox tiene un Tabla de clasificación integrado para mostrar las estadísticas del usuario. Cuando estableces los puntos del jugador a través de la tabla de clasificación, aparecen en el lado derecho de la pantalla en la experiencia.

Leaderboard with username and points shown

Aprenderás más formas personalizadas de mostrar información en tutoriales posteriores, pero la tabla de clasificación es la forma más sencilla de hacer un sistema de puntuación visible en Roblox.

Es mejor poner scripts que configuran el estado de la experiencia en ServerScriptService porque se ejecutarán automáticamente cuando la experiencia comience. En ServerScriptService , crea un script llamado SetupPoints .

SetupPoints script in place in ServerScriptService in the Explorer window

Escuchando a los jugadores

En Roblox, un servicio es un objeto que realiza una variedad de funciones útiles. El servicio Players tiene un evento llamado PlayerAdded que puedes usar para configurar puntos para cada usuario que se une a la experiencia.

Puede acceder a los servicios con la función GetService en el objeto game. game es una función de variable accesible desde cualquier lugar que contiene todo en tu experiencia.

Crea una variable para el servicio de Jugadores usando game:GetService("Players") .
Crea una función llamada onPlayerAdded con un parámetro para el jugador entrante.

Conecta la función onPlayerAdded al evento PlayerAdded.


local Players = game:GetService("Players")

local function onPlayerAdded(player)

end

Players.PlayerAdded:Connect(onPlayerAdded)

Al declarar una variable para contener un servicio, es mejor nombrarla con el nombre exacto del servicio ( "Players" )), incluso si esto significa romper las reglas de nombrado habituales para las variables.

Crear una carpeta de estadísticas

Para hacer que los puntos de un usuario se muestren en la tabla de clasificación, todo lo que necesitas es crear un nuevo Folder en su objeto Player llamado "leaderstats" y poner sus puntos en él. Los objetos nuevos se pueden crear desde dentro de un script a través de la función 2>Datatype.Instance.new()2> dentro de una función.

Cree un nuevo objeto Folder usando Instance.new("Folder") , almacenando el resultado en una nueva variable llamada leaderstats .


local function onPlayerAdded(player)
	local leaderstats = Instance.new("Folder")
end

Establece la propiedad de Nombre de leaderstats a "leaderstats" .

Padre leaderstats a player .


local Players = game:GetService("Players")

local function onPlayerAdded(player)
	local leaderstats = Instance.new("Folder")
   leaderstats.Name = "leaderstats"
   leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)

¡Asegúrese de que el directorio se llame exactamente como se muestra aquí ( "leaderstats" ) o no funcionará!

Creando los Puntos

El sistema de clasificación lee cualquier valor en la carpeta leaderstats y muestra lo que encuentra.

Para agregar una estadística que rastreará los puntos de un jugador, un nuevo objeto IntValue puede agregarse a la carpeta leaderstats. El nombre del objeto de valor se mostrará junto con su valor actual.

Usa una variable llamada points para crear un nuevo objeto IntValue usando Instance.new() .
Establece el Name a "Points" .
Establece el Value a 0 ; esto es lo que la tabla de clasificación mostrará inicialmente para el jugador.
Padre el objeto points a la carpeta leaderstats.


local Players = game:GetService("Players")

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats
end

Players.PlayerAdded:Connect(onPlayerAdded)

Prueba tu experiencia y deberías ver aparecer la tabla de clasificación en la parte superior derecha con los nombres de tus usuarios y un puntaje de puntos junto a ellos.

Contando el tiempo

Cada usuario debería ganar un punto por cada segundo que esté vivo. Un bucle while y la función task.wait() se pueden usar para actualizar el valor de los puntos cada segundo.

Al final del script, crea un bucle de while con true como condición.
En el bucle, task.wait() por 1 segundo.


Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Lista de jugadores

Para ejecutar el código para cada usuario en la experiencia, necesitas repetir a través del array de usuarios devueltos por la función GetPlayers.

Un matriz es una lista de elementos almacenados en orden. Cada elemento puede ser accedido por su posición de índice, comenzando con 1 . Puedes obtener la longitud de una matriz prefiere con # .

Almacena el resultado de Players:GetPlayers() en una variable playerList
Crea un para bucle con un valor de inicio de 1 y un valor de finalización de #playerList , para que obtengas un itener del bucle por jugador.


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    -- Añade tu lógica aquí para cada jugador en la lista de jugadores
  end
end

Otorgando puntos

Para otorgar un punto a cada usuario en el for loop, necesitarás sacar al usuario del arreglo y agregar 1 a Puntos objeto almacenado en su leaderstats Cartera.

Los objetos almacenados en un matriz se acceden usando códigos de flecha - por instancia, el primer artículo en la matriz playerList se puede acceder con playerList[1] . Si escribes 1> playerList[currentPlayer)1> en la for loop, puedes moverte a través de cada usuario en la lista con cada itación de la for loop.

Almacene al usuario en playerList[currentPlayer] en una variable llamada player .
Almacena el objeto de usuario Puntos en una variable llamada points .
Establece la propiedad Value de points a points.Value + 1 .


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]
    local points = player.leaderstats.Points
    points.Value += 1
  end
end

Prueba tu experiencia y deberías encontrar que la tabla de clasificación muestra el puntaje de tu jugador contando por 1 cada segundo.

Escuchando para Personajes

El objetivo de la experiencia es ver quién puede quedarse vivo el mayor tiempo, por lo que los usuarios que mueren tendrán que tener sus puntos restablecidos a 0.

Necesitarás obtener el modelo de Personaje para el usuario para poder detectar cuando ha muerto. Este modelo se agrega solo a la experiencia después que el objeto Player haya sido cargado y puedas usar el evento 2> Class.jugador.CharacterAdded|CharacterAdded</


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")

Aunque incluiste a un usuario en los parámetros de la función onCharacterAdded, el evento actual CharacterAdded solo devuelve el personaje, no el usuario asociado. Para pasar el objeto de usuario player a la vez, usa una función 1>anónima1> para la conexión del evento.


local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Restableciendo Puntos

Cuando un usuario muere, su Humanoid dispara automáticamente un evento Died. Puedes usar este evento para encontrar cuándo restablecer sus puntos.

El Húmedo se encuentra dentro del aplicación de modeladode Personaje, pero los contenidos de ese modelo solo se montan cuando el usuario genera. Para hacer que su código se cargarcon seguridad, use la función WaitForChild(). Puede llamarlo en cualquier objeto padre, pasando el nombre de la cadena del niño que está esperando. Cree una variable para esperar al Húmed


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")
end

La función que necesitas para conectarte al evento de Died es muy corta y solo se necesitará aquí, para que puedas usar una función anónima de nuevo.

Conecta una nueva función anónima al evento Muerto del Humanoid.
En la función anónima, crea una variable llamada points para el objeto de Puntos del jugador.
Establece la propiedad Value de points a 0 .


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
  end)
end

Prueba esto y verás que el puntaje del usuario se reinicia cuando muere.

Revisando al jugador

Si los usuarios siguen ganando puntos incluso cuando están muertos, es casi en el espíritu de la experiencia, por lo que el código necesita verificar si los usuarios están vivos antes de otorgar un punto.

Necesitas comenzar definiendo un atributo en el código de función que se puede usar para ver si el usuario está vivo. En este punto, el usuario aún no está vivo y se ha generado, ya que su modelo de personaje aún se debe agregar.

Las atributos te permiten personalizar objetos en Roblox con tus propios datos. Un atributo consiste en un nombre y un valor. Puedes crear uno en cualquier objeto usando la función SetAttribute. Llamar Class.Instance:SetAttribute()|Class.Instance


local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Una vez que el modelo de personaje del usuario se reaparece, el valor de IsAlive debe cambiarse a true para que el usuario pueda comenzar a ganar puntos de nuevo.

En onCharacterAdded, establece el atributo IsAlive de player en 1> verdadero1> .
En onCharacterDied, establece el atributo IsAlive de player a 1> falso1> .


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)

  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

Finalmente, IsAlive debería ser verificado antes de que se otorgue cualquier punto en el while bucle al final del script. La función 1> Class.Instance:GetAttribute()|GetAttribute1> toma


while true do
  task.wait(1)
  local playerList = Players:GetPlayers()

  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]

    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end

Prueba tu experiencia ahora y deberías encontrar que el usuario gana puntos cada segundo que esté vivo, y se queda en 0 cuando no está vivo. Haz que tus amigos jueguen contigo y vea quién puede obtener la mayor puntuación.

Este es solo el iniciar: puede continuar mejorando su experiencia para sus usuarios. Aquí hay algunos consejos:

Coloque el código para todas las plataformas en un solo script, lo que facilita mucho la actualización.
Crea un área de lobby donde los usuarios esperan para ser teletransportados a la zona de experiencia, permitiendo que los usuarios comienzen simultáneamente.
Anuncia los ganadores de cada ronda.

Código Final


local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for i = 1, #playerList do
    local player = playerList[i]
    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end