Puntuar

En tutoriales anteriores, creaste una variedad de características del juego, incluyendo plataformas que desaparecen y lava mortal. Este tutorial une todo esto en un juego jugable donde los usuarios ven quién puede mantenerse vivo el mayor tiempo posible. Cada segundo que permanezcan vivos, se añadirá un punto a su puntuación.

Configuración

Primero, necesitarás preparar la escena para tu juego. Duplica las plataformas que desaparecen que hiciste en el tutorial anterior y deja que los usuarios compitan para permanecer en la plataforma el mayor tiempo posible.

También puedes usar lava mortal para matar a los usuarios cuando caen de las plataformas, o simplemente dejarlos caer a su perdición. Asegúrate de colocar un SpawnLocation en algún lugar donde los usuarios puedan saltar a las plataformas para comenzar a jugar.

Puntos del jugador

Roblox tiene un Leaderboard incorporado para mostrar las estadísticas de los usuarios. Cuando configuras los puntos del jugador a través del leaderboard, aparecen en el lado derecho de la pantalla en el juego.

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

Es mejor colocar los scripts que configuran el estado del juego en ServerScriptService porque se ejecutarán automáticamente cuando comience el juego. En ServerScriptService, crea un script llamado SetupPoints.

Escuchar 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 los puntos de cada usuario que se une al juego.

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

1. Crea una variable para el servicio Players usando game:GetService("Players").

2. Crea una función llamada onPlayerAdded con un parámetro para el jugador entrante.

3. Conecta la función onPlayerAdded al evento PlayerAdded.

   local Players = game:GetService("Players")
   
   local function onPlayerAdded(player)
   
   end
   
   Players.PlayerAdded:Connect(onPlayerAdded)

Crear una carpeta de estadísticas

Para que los puntos de un usuario se muestren en el leaderboard, todo lo que necesitas hacer es crear una nueva Folder en su objeto Player llamada "leaderstats" y poner sus puntos allí. Nuevos objetos pueden ser creados desde dentro de un script a través de la función Instance.new().

1. Crea 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

2. Establece la propiedad Name de leaderstats a "leaderstats".

3. Parent leaderstats al 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)

Crear los puntos

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

Para añadir una estadística que rastree los puntos de un jugador, se puede parentar un nuevo objeto IntValue a la carpeta leaderstats. El nombre del objeto de valor se mostrará junto a su valor actual.

1. Usa una variable llamada points para crear un nuevo objeto IntValue usando Instance.new().
2. Establece el Name a "Points".
3. Establece el Value a 0; esto es lo que el leaderboard mostrará inicialmente para el jugador.
4. Parent 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 juego y deberías ver que el leaderboard aparece en la parte superior derecha con los nombres de tus usuarios y una puntuación de puntos junto a ellos.

Contar 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.

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

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Lista de jugadores

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

Un array es una lista de elementos almacenados en orden. Cada elemento puede ser accedido por su posición de índice, comenzando desde 1. Puedes obtener la longitud de un array anteponiéndolo con #.

1. Almacena el resultado de Players:GetPlayers() en una variable playerList.
2. Crea un bucle for con un valor inicial de 1 y un valor final de #playerList, de modo que obtengas una iteración del bucle por cada 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 playerList
  end
end

Otorgar puntos

Para otorgar un punto a cada usuario en el bucle for, necesitarás sacar al usuario del array y añadir 1 al objeto Points almacenado en su carpeta leaderstats.

Los objetos almacenados en un array se acceden usando corchetes cuadrados - por ejemplo, el primer elemento en el array playerList se puede acceder con playerList[1]. Si escribes playerList[currentPlayer] en el bucle for, puedes moverte a través de cada usuario en la lista con cada iteración del bucle.

1. Almacena el usuario en playerList[currentPlayer] en una variable llamada player.
2. Almacena el objeto Points del usuario en una variable llamada points.
3. 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 juego y deberías encontrar que el leaderboard muestra la puntuación de tu jugador aumentando en 1 cada segundo.

Escuchar a los personajes

El objetivo del juego es ver quién puede mantenerse vivo el mayor tiempo, así que los usuarios que mueren necesitarán que sus puntos se restablezcan a 0.

Necesitarás obtener el modelo de Character para el usuario para detectar cuándo ha muerto. Este modelo solo se añade al juego después de que el objeto Player ha sido cargado y puedes usar el evento CharacterAdded para escuchar cuándo el personaje está listo para usar. Crea una función llamada onCharacterAdded con dos parámetros: uno para el personaje, uno para el jugador.

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

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

Aunque incluiste al usuario en los parámetros de la función onCharacterAdded, el evento real CharacterAdded solo devuelve el personaje, no el usuario asociado. Para pasar el objeto player también, usa una función anónima 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

Restablecer puntos

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

El Humanoid se encuentra dentro del modelo Character, pero el contenido de ese modelo solo se ensambla a medida que el usuario aparece. Para hacer que tu código espere de manera segura a que se cargue el objeto Humanoid, usa la función WaitForChild(). Puedes llamarla en cualquier objeto padre, pasando el nombre de cadena del hijo que estás esperando. Crea una variable para esperar al Humanoid usando character:WaitForChild("Humanoid").

local Players = game:GetService("Players")

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

La función que necesitas conectar al evento Died es muy corta y solo se necesitará aquí, así que puedes usar una función anónima nuevamente.

1. Conecta una nueva función anónima al evento Died del Humanoid.
2. En la función anónima, crea una variable llamada points para el objeto Points del jugador.
3. 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 la puntuación del usuario se restablece cuando muere.

Comprobar al jugador

Si los usuarios siguen ganando puntos incluso cuando están muertos, no está en el espíritu del juego, así que el código necesita verificar si los usuarios están vivos antes de otorgar un punto.

Necesitas comenzar definiendo un atributo en la función onPlayerAdded que se pueda usar para verificar si el usuario está vivo. En este punto, el usuario aún no está vivo y no ha aparecido, ya que su modelo de personaje aún necesita ser añadido.

Los 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. Llama a SetAttribute en player para crear un nuevo atributo llamado "IsAlive" con el valor false.

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 respawnea, el valor de IsAlive necesita cambiarse a true para que el usuario pueda comenzar a ganar puntos nuevamente.

1. En onCharacterAdded, establece el atributo IsAlive de player a true.
2. En onCharacterDied, establece el atributo IsAlive de player a false.

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 debe ser verificado antes de que se otorgue cualquier punto en el bucle while al final del script. La función GetAttribute toma el nombre de un atributo y devuelve el valor. En el bucle while, envuelve el código para otorgar un punto en una declaración if con la condición player:GetAttribute("IsAlive").

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 juego ahora y deberías encontrar que el usuario gana puntos cada segundo que está vivo, y se mantiene en 0 cuando no está vivo. Haz que tus amigos jueguen contigo y ve quién puede obtener la puntuación más alta.

Esto es solo el comienzo: puedes seguir mejorando tu juego para tus usuarios. Aquí hay algunos consejos:

• Coloca el código para todas las plataformas en un solo script, lo que facilita mucho la actualización.
• Crea un área de vestíbulo donde los usuarios esperen ser teletransportados al área del juego, permitiendo que los usuarios comiencen simultáneamente.
• Anuncia a 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