Puntuación de puntos

En tutoriales anteriores, hiciste una variedad de características de experiencia que incluyen plataformas que desaparecen y lava mortal. Este tutorial une todo esto en una experiencia jugable donde los usuarios ven quién puede sobrevivir más tiempo. Cada segundo que se mantengan vivos, se añadirá un punto a su puntuación.

Configurar

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

También puedes usar lava mortal para eliminar a los usuarios cuando caen de las plataformas, o simplemente dejar que caigan 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 estadísticas de los usuarios. Cuando estableces los puntos del jugador a través del tablero, aparecen en el lado derecho de la pantalla en la experiencia.

Aprenderás formas más personalizables para mostrar información en tutoriales posteriores, pero el tablero es la manera más simple de hacer un sistema de puntuación visible en Roblox.

Es mejor colocar los scripts que configuran el estado de la experiencia en ServerScriptService porque se ejecutarán automáticamente cuando comience la experiencia. 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 puntos para cada usuario que se una a la experiencia.

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

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 tablero, todo lo que necesitas hacer es crear un nuevo Folder en su objeto Player llamado "leaderstats" y poner sus puntos allí. Se pueden crear nuevos objetos desde 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. Haz que leaderstats sea hijo de 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 tablero lee cualquier valor en la carpeta leaderstats y muestra todo lo que encuentra.

Para agregar una estadística que rastree los puntos de un jugador, se puede añadir un nuevo objeto IntValue a la carpeta leaderstats. El nombre del objeto de valor se mostrará junto con 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 tablero mostrará inicialmente para el jugador.
4. Haz que el objeto points sea hijo de 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 que el tablero aparece en la parte superior derecha con los nombres de tus usuarios y una puntuación de puntos junto a ellos.

Contar el tiempo

Cada usuario debería ganar un punto por cada segundo que esté vivo. Un bucle while y la función task.wait() pueden utilizarse 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 la experiencia, 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 índice, comenzando desde 1. Puedes obtener la longitud de un array prefijá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, para 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 puede ser accedido 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 experiencia y deberías descubrir que el tablero muestra la puntuación de tu jugador aumentando en 1 cada segundo.

Escuchar a los personajes

El objetivo de la experiencia es ver quién puede sobrevivir más tiempo, así que los usuarios que mueren necesitarán tener sus puntos restablecidos a 0.

Necesitarás obtener el modelo de Character para el usuario para poder detectar cuándo ha muerto. Este modelo solo se añade a la experiencia después de que se haya cargado el objeto Player 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, utiliza 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, utiliza la función WaitForChild(). Puedes llamarla en cualquier objeto principal, 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 nuevamente una función anónima.

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 el jugador

Si los usuarios siguen ganando puntos incluso cuando están muertos, no está en el espíritu de la experiencia, 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 pueda ser utilizado 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 todavía necesita ser añadido.

Los atributos permiten personalizar objetos en Roblox con tus propios datos. Un atributo consiste en un nombre y un valor. Puedes crear uno en cualquier objeto utilizando 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 del personaje del usuario respawne, el valor de IsAlive necesita ser cambiado 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 experiencia 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 continuar mejorando tu experiencia para tus usuarios. Aquí hay algunos consejos:

• Coloca el código para todas las plataformas en un solo script, haciéndolo mucho más fácil de actualizar.
• Crea un área de vestíbulo donde los usuarios esperen ser teletransportados a la zona de experiencia, 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