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

Em tutoriais anteriores, você fez uma variedade de recursos de experiência, incluindo plataformas desvanescentes e lava mortal. Este tutorial conecta esses recursos juntos em uma experiência interativa onde os usuários vêem quem pode ficar vivo mais tempo. Cada segundo que eles ficam vivos, um ponto será adicionado à sua pontuação.

Configurando

Primeiro, você precisará configurar a cena para sua experiência. Duplique as plataformas desvanecentes que você fez no tutorial anterior e deixe os usuários competirem para ficar no quadro de plataformas por mais tempo possível.

Você também pode usar lava mortal para matar usuários quando eles cairem das plataformas, ou apenas deixá-los cair para sua perdição. Certifique-se de colocar um SpawnLocation em algum lugar onde os usuários podem pular nas plataformas para começar a jogar.

Pontos do Jogador

O Roblox tem um Leaderboard integrado para mostrar estatísticas do usuário. Quando você configura pontos de jogador através do classificação, eles aparecem no lado direito da tela na experiência.

Leaderboard with username and points shown

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

É melhor colocar scripts que configuram o estado da experiência em ServerScriptService porque eles serão executados automaticamente quando a experiência começar. Em ServerScriptService , crie um script chamado SetupPoints .

SetupPoints script in place in ServerScriptService in the Explorer window

Ouvindo os Jogadores

No Roblox, um serviço é um objeto que executa uma variedade de funções úteis. O serviço Players tem um evento chamado PlayerAdded que você pode usar para configurar pontos para cada usuário que se juntar à experiência.

Você pode acessar serviços com a função GetService no Objetogame. 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 entrante.

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 quebre as convenções de nomeação padrão para variáveis.

Crie uma pasta estatística

Para fazer com que os pontos de um usuário estejam na tabela de classificação, tudo o que você precisa fazer é criar um novo Folder em seu objeto Player chamado "leaderstats" e colocar seus pontos nele. Novos objetos podem ser criados a partir dentro de um script via a função 2>Datatype.Instance.new()2>.

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 de Nome de leaderstats para "leaderstats".

Parente 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 renomear o pasta exatamente como está mostrado aqui ( "leaderstats" ) ou não funcionará!

Criando os Pontos

O sistema de classificação lê quaisquer valores no leaderstats pasta e exibe o que encontrar.

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

Use uma variável chamada points para criar um novo objeto IntValue usando Instance.new() .
Defina o Name para "Points" .
Defina o Value para 0 ; isso é o que o placar inicialmente exibirá para o jogador.
Parent the points object to the leaderstats folder.


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 a tabela de classificação aparecer no canto superior direito com nomes de seus usuários e uma pontuação de pontos ao lado deles.

Tempo de Contagem

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.

No final do script, crie um while loop com true como condição.
Em 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 itera através do array de usuários retornados pela função GetPlayers.

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

Armazenar o resultado de Players:GetPlayers() em uma variável playerList.
Crie um para loop com um valor de início de 1 e um valor de fim de #playerList, para que você obtenha um 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

Pontos de Recompensa

Para atribuir um ponto a cada usuário na força, você precisará fazer o usuário sair da matriz e adicionar 1 ao objeto Pontos armazenado em seu pasta leaderstats.

Objetos armazenados em um array são acessados usando aspas retornas - por instância, o primeiro item na lista playerList pode ser acessado com playerList[1]. Se você escrever 1>playerList[currentPlayer]1> na força, você pode mover através de cada usuário na lista com cada iteração da força.

Armazenar o usuário em playerList[currentPlayer] em uma variável chamada player .
Armazenar o objeto de Pontos do usuário em uma variável chamada points .
Defina a propriedade Value de points para 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 encontrar que a tabela de classificação mostra a pontuação de seu jogador contando por 1 a cada segundo.

Ouvindo por Personagens

O objetivo da experiência é ver quem pode ficar vivo mais tempo, então os usuários que morrem precisarão ter seus pontos redefinidos para 0.

Você precisará obter o modelo Personagem para o usuário para detectar quando eles morreram. Este modelo só é adicionado à experiência depois que o objeto Player for carregado e você pode usar o evento 2> Class.jogador.CharacterAdded|


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 na função onCharacterAdded, o evento de fato CharacterAdded retorna apenas o personagem, não o usuário associado. Para passar o objeto player como também, use uma função anônima para 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

Resetando Pontos

Quando um usuário morre, seu Humanoid ativa automaticamente um evento Died. Você pode usar este evento para encontrar quando redefinir seus pontos.

O Humanoide é encontrado dentro do modelo Personagem, mas os conteúdos desse modelo só são montados quando o usuário invoca. Para fazer com que seu código seja carregarcom segurança, use a função WaitForChild(). Você pode chamá-lo em qualquer Objetode pai, passando o nome de estrangulador do filho que


local Players = game:GetService("Players")

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

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

Conecte uma nova função anônima ao evento Morto do Humanoid.
Na função anônima, crie uma variável chamada points para o Objeto Pontos do jogador.
Defina a propriedade Value de points para 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 redefinida quando eles morrerem.

Verificando o Jogador

Se os usuários continuarem ganhando pontos, mesmo quando estiverem mortos, ele não está no espírito da experiência, então o código precisa verificar se os usuários estão vivos antes de conceder um ponto.

Você precisa começar definindo um ativo 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 gerado, como 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 Class.Instance:SetAttribute()|Class


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 é respawnado, o valor de IsAlive precisa ser alterado para true para que o usuário possa começar a ganhar pontos novamente.

In onCharacterAdded, set the IsAlive attribute of player to 1> true1> .
In onCharacterDied, set the IsAlive attribute of player to 1> false1>.


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 concedido no while loop no final do script. A função while leva o nome de um atributo e retorna o


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 encontrar que o usuário ganha pontos cada segundo que estiver vivo, e fica em 0 quando não estiver vivo. Peça a seus amigos para jogar com você e ver quem pode obter a maior pontuação.

Este é apenas o iniciar: 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 atualização.
Crie uma área de lobby onde os usuários esperam para serem teletransportados para a área de experiência, permitindo que os usuários comecem simultaneamente.
Anúncie 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