Pontos de pontuação

Nos tutoriais anteriores, você criou uma variedade de recursos de jogo, incluindo plataformas que desaparecem e lava mortal. Este tutorial junta tudo isso em um jogo jogável onde os usuários veem quem consegue ficar vivo por mais tempo. A cada segundo que eles permanecem vivos, um ponto será adicionado à sua pontuação.

Configurar

Primeiro, você precisará preparar o cenário para o seu jogo. Duplique as plataformas que desaparecem que você fez no tutorial anterior e deixe os usuários competirem para ficar na plataforma o maior tempo possível.

Você também pode usar lava mortal para eliminar os usuários quando eles caírem das plataformas, ou apenas deixá-los cair para a sua morte. Certifique-se de colocar um SpawnLocation em algum lugar onde os usuários possam pular nas plataformas para começar a jogar.

Pontos do jogador

Roblox tem um Leaderboard embutido para mostrar as estatísticas dos usuários. Quando você define os pontos dos jogadores através do leaderboard, eles aparecem no lado direito da tela no jogo.

Você aprenderá maneiras mais personalizáveis de exibir informações em tutoriais posteriores, mas o leaderboard é a maneira mais simples de criar um sistema de pontuação visível no Roblox.

É melhor colocar scripts que configuram o estado do jogo no ServerScriptService porque eles serão executados automaticamente quando o jogo começar. No ServerScriptService, crie um script chamado SetupPoints.

Ouvir por jogadores

No Roblox, um serviço é um objeto que realiza uma variedade de funções úteis. O serviço Players tem um evento chamado PlayerAdded que você pode usar para configurar os pontos para cada usuário que entra no jogo.

Você pode acessar serviços com a função GetService no objeto game. game é uma variável acessível de qualquer lugar que contém tudo no seu jogo.

1. Crie uma variável para o serviço Players usando game:GetService("Players").

2. Crie uma função chamada onPlayerAdded com um parâmetro para o jogador que está entrando.

3. Conecte a função onPlayerAdded ao evento PlayerAdded.

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

Criar uma pasta de estatísticas

Para fazer os pontos de um usuário aparecerem no leaderboard, tudo o que você precisa fazer é criar uma nova Folder no objeto Player deles chamado "leaderstats" e colocar os pontos lá. Novos objetos podem ser criados a partir de um script através da função Instance.new().

1. Crie um novo objeto Folder usando Instance.new("Folder"), armazenando o resultado em uma nova variável chamada leaderstats.

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

2. Defina a propriedade Name de leaderstats como "leaderstats".

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

Criar os pontos

O sistema de leaderboard lê quaisquer valores na pasta leaderstats e exibe o que encontrar.

Para adicionar uma estatística que rastreará os pontos de um jogador, um novo objeto IntValue pode ser parentado à pasta leaderstats. O nome do objeto de valor será exibido ao lado do seu valor atual.

1. Use uma variável chamada points para criar um novo objeto IntValue usando Instance.new().
2. Defina o Name como "Points".
3. Defina o Value como 0; isso é o que o leaderboard exibirá inicialmente para o jogador.
4. Parent o objeto points à pasta 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)

Teste seu jogo e você deve ver o leaderboard aparecer no canto superior direito com os nomes dos seus usuários e uma pontuação ao lado deles.

Contar o tempo

Cada usuário deve ganhar um ponto por cada segundo que estiver vivo. Um loop while e a função task.wait() podem ser usados para atualizar o valor dos pontos a cada segundo.

1. No final do script, crie um loop while com true como condição.
2. No loop, task.wait() por 1 segundo.

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Lista de jogadores

Para executar código para cada usuário no jogo, você precisa iterar pela array de usuários retornada pela função GetPlayers.

Uma array é uma lista de itens armazenados em ordem. Cada item pode ser acessado pela sua posição de índice, começando de 1. Você pode obter o comprimento de uma array prefixando-a com #.

1. Armazene o resultado de Players:GetPlayers() em uma variável playerList.
2. Crie um loop for com um valor inicial de 1 e um valor final de #playerList, para que você obtenha uma iteração do loop por jogador.

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    -- Adicione sua lógica aqui para cada jogador na playerList
  end
end

Premiar pontos

Para premiar um ponto a cada usuário no loop for, você precisará obter o usuário da array e adicionar 1 ao objeto Points armazenado na pasta leaderstats deles.

Objetos armazenados em uma array são acessados usando colchetes - por exemplo, o primeiro item na array playerList pode ser acessado com playerList[1]. Se você escrever playerList[currentPlayer] no loop for, poderá percorrer cada usuário na lista a cada iteração do loop.

1. Armazene o usuário em playerList[currentPlayer] em uma variável chamada player.
2. Armazene o objeto Points do usuário em uma variável chamada points.
3. Defina a propriedade Value de points como 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

Teste seu jogo e você deve descobrir que o leaderboard mostra a pontuação do seu jogador aumentando em 1 a cada segundo.

Ouvir por personagens

O objetivo do jogo é ver quem consegue ficar vivo por mais tempo, então os usuários que morrem precisarão ter seus pontos redefinidos para 0.

Você precisará obter o modelo Character do usuário para detectar quando ele morreu. Este modelo só é adicionado ao jogo após o objeto Player ter sido carregado e você pode usar o evento CharacterAdded para ouvir quando o personagem estiver pronto para uso. Crie uma função chamada onCharacterAdded com dois parâmetros: um para o personagem, um para o jogador.

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

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

Embora você tenha incluído o usuário nos parâmetros da função onCharacterAdded, o evento real CharacterAdded só retorna o personagem, não o usuário associado. Para passar o objeto player também, use uma função anônima para a conexão do 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

Redefinir pontos

Quando um usuário morre, seu Humanoid dispara automaticamente um evento Died. Você pode usar esse evento para descobrir quando redefinir seus pontos.

O Humanoid é encontrado dentro do modelo Character, mas o conteúdo desse modelo só é montado quando o usuário aparece. Para fazer seu código esperar com segurança o objeto Humanoid carregar, use a função WaitForChild(). Você pode chamá-la em qualquer objeto pai, passando o nome da string do filho que você está esperando. Crie uma variável para esperar pelo Humanoid usando character:WaitForChild("Humanoid").

local Players = game:GetService("Players")

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

A função que você precisa conectar ao evento Died é muito curta e só será necessária aqui, então você pode usar uma função anônima novamente.

1. Conecte uma nova função anônima ao evento Died do Humanoid.
2. Na função anônima, crie uma variável chamada points para o objeto Points do jogador.
3. Defina a propriedade Value de points como 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

Teste isso e você verá que a pontuação do usuário é redefinida quando ele morre.

Verificar o jogador

Se os usuários continuarem ganhando pontos mesmo quando mortos, isso não está de acordo com o espírito do jogo, então o código precisa verificar se os usuários estão vivos antes de premiar um ponto.

Você precisa começar definindo um atributo na função onPlayerAdded que pode ser usado para verificar se o usuário está vivo. Neste ponto, o usuário ainda não está vivo e não apareceu, pois seu modelo de personagem ainda precisa ser adicionado.

Atributos permitem que você personalize objetos no Roblox com seus próprios dados. Um atributo consiste em um nome e um valor. Você pode criar um em qualquer objeto usando a função SetAttribute. Chame SetAttribute em player para criar um novo atributo chamado "IsAlive" com o 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

Uma vez que o modelo de personagem do usuário respawn, o valor de IsAlive precisa ser alterado para true para que o usuário possa começar a ganhar pontos novamente.

1. Em onCharacterAdded, defina o atributo IsAlive de player como true.
2. Em onCharacterDied, defina o atributo IsAlive de player como 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 deve ser verificado antes de qualquer ponto ser premiado no loop while no final do script. A função GetAttribute recebe o nome de um atributo e retorna o valor. No loop while, envolva o código para premiar um ponto em uma declaração if com a condição 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

Teste seu jogo agora e você deve descobrir que o usuário ganha pontos a cada segundo que está vivo, e permanece em 0 quando não está vivo. Faça seus amigos jogarem com você e veja quem consegue a maior pontuação.

Isso é apenas o começo: você pode continuar melhorando seu jogo para seus usuários. Aqui estão algumas dicas:

• Coloque o código para todas as plataformas em um único script, tornando muito mais fácil de atualizar.
• Crie uma área de lobby onde os usuários esperam para serem teleportados para a área do jogo, permitindo que os usuários comecem simultaneamente.
• Anuncie os vencedores de cada rodada.

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