Pontos de Pontuação | Documentação - Central de Criadores Roblox

Nos tutoriais anteriores, você fez uma variedade de recursos de experiência, incluindo plataformas que desaparecem e lava mortal. Este tutorial une esses elementos em uma experiência jogável onde os usuários veem quem pode ficar vivo por mais tempo. A cada segundo que eles permanecem vivos, um ponto será adicionado à sua pontuação.

Configurar

Primeiro, você precisará configurar o cenário para sua experiência. Duplique as plataformas que desaparecem que você criou no tutorial anterior e deixe os usuários competirem para ficar no tabuleiro de plataformas o maior tempo possível.

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

Ponto de spawn acima de uma grade de plataformas que desaparecem, acima de um chão de lava

Pontos dos Jogadores

Roblox possui 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 na experiência.

Leaderboard com nome de usuário e pontos mostrados

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 da experiência dentro do ServerScriptService, pois eles serão executados automaticamente quando a experiência começar. No ServerScriptService, crie um script chamado SetupPoints.

Script SetupPoints no lugar no ServerScriptService na janela Explorer

Ouvir pelos 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 se junta à experiência.

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 na sua experiência.

Crie uma variável para o serviço Players usando game:GetService("Players").
Crie uma função chamada onPlayerAdded com um parâmetro para o jogador que está entrando.

Conecte a função onPlayerAdded ao evento PlayerAdded.


local Players = game:GetService("Players")

local function onPlayerAdded(player)

end

Players.PlayerAdded:Connect(onPlayerAdded)

Ao declarar uma variável para conter um serviço, é melhor nomeá-la com o nome exato do serviço ("Players"), mesmo que isso signifique quebrar as convenções de nomeação habituais para variáveis.

Criar uma pasta de estatísticas

Para que os pontos de um usuário sejam exibidos 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 via a função Instance.new().

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

Defina a propriedade Name de leaderstats como "leaderstats".

Parent leaderstats para 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)

Certifique-se de nomear a pasta exatamente como mostrado aqui ("leaderstats") ou não funcionará!

Criar os pontos

O sistema de leaderboard lê qualquer valor 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.

Use uma variável chamada points para criar um novo objeto IntValue usando Instance.new().
Defina o Name como "Points".
Defina o Value como 0; isso é o que o leaderboard exibirá inicialmente para o jogador.
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 sua experiência 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 para 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.

No final do script, crie um loop while com true como condição.
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 na experiência, 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 #.

Armazene o resultado de Players:GetPlayers() em uma variável playerList.
Crie um loop for com um valor inicial de 1 e um valor final de #playerList, de modo 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 dele.

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.

Armazene o usuário em playerList[currentPlayer] em uma variável chamada player.
Armazene o objeto Points do usuário em uma variável chamada points.
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 sua experiência e você deve descobrir que o leaderboard mostra a pontuação do seu jogador subindo em 1 a cada segundo.

Ouvir pelos personagens

O objetivo da experiência é ver quem pode 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 para o usuário para detectar quando eles morreram. Este modelo é adicionado à experiência 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 user 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, o 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 reaparece. Para que seu código aguarde com segurança o carregamento do objeto Humanoid, use a função WaitForChild(). Você pode chamá-la em qualquer objeto pai, passando o nome da string do filho pelo qual 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.

Conecte uma nova função anônima ao evento Died do Humanoid.
Na função anônima, crie uma variável chamada points para o objeto Points do jogador.
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á a pontuação do usuário sendo redefinida quando ele morrer.

Verificar o jogador

Se os usuários continuarem ganhando pontos mesmo quando mortos, isso não está de acordo com o espírito da experiência, 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 foi gerado, pois o modelo do personagem ainda precisa ser adicionado.

Atributos permitem que você personaliza 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

Assim que o modelo do personagem do usuário reapercer, o valor de IsAlive precisa ser mudado para true para que o usuário possa começar a ganhar pontos novamente.

Em onCharacterAdded, defina o atributo IsAlive de player como true.
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 sua experiência 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. Deixe seus amigos jogarem com você e veja quem consegue a maior pontuação.

Isso é apenas o começo: você pode continuar melhorando sua experiência 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 da experiência, 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