Marquer des points

Dans les tutoriels précédents, vous avez créé une variété de fonctionnalités d'expérience, y compris des plateformes fade et de la lave mortelle. Ce tutoriel relie ces éléments ensemble dans une expérience jouable où les utilisateurs voient qui peut rester en vie le plus longtemps. Chaque seconde qu'ils restent en vie, un point sera ajouté à leur score.

Configuration

Tout d'abord, vous devrez préparer la scène pour votre expérience. Dupliquez les plateformes fade que vous avez créées dans le tutoriel précédent et laissez les utilisateurs concourir pour rester sur le plateau de plateformes le plus longtemps possible.

Vous pouvez également utiliser la lave mortelle pour tuer les utilisateurs lorsqu'ils tombent des plateformes, ou simplement les laisser tomber dans leur destin. Assurez-vous de placer un SpawnLocation quelque part où les utilisateurs peuvent sauter sur les plateformes pour commencer à jouer.

Points des joueurs

Roblox a un Leaderboard intégré pour afficher les statistiques des utilisateurs. Lorsque vous définissez les points des joueurs via le leaderboard, ils apparaissent sur le côté droit de l'écran dans l'expérience.

Vous apprendrez des façons plus personnalisables d'afficher des informations dans les tutoriels ultérieurs, mais le leaderboard est la méthode la plus simple pour créer un système de notation visible dans Roblox.

Il est préférable de placer les scripts qui établissent l'état de l'expérience dans ServerScriptService car ils s'exécutent automatiquement lorsque l'expérience commence. Dans ServerScriptService, créez un script appelé SetupPoints.

Écouter les joueurs

Dans Roblox, un service est un objet qui effectue une gamme de fonctions utiles. Le service Players a un événement appelé PlayerAdded que vous pouvez utiliser pour configurer les points pour chaque utilisateur qui rejoint l'expérience.

Vous pouvez accéder aux services avec la fonction GetService dans l'objet game. game est une variable accessible de n'importe où qui contient tout dans votre expérience.

1. Créez une variable pour le service Players en utilisant game:GetService("Players").

2. Créez une fonction appelée onPlayerAdded avec un paramètre pour le joueur entrant.

3. Connectez la fonction onPlayerAdded à l'événement PlayerAdded.

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

Créer un dossier de statistiques

Pour faire afficher les points d'un utilisateur dans le leaderboard, tout ce que vous avez à faire est de créer un nouveau Folder dans leur objet Player appelé "leaderstats" et d'y mettre leurs points. De nouveaux objets peuvent être créés à partir d'un script via la fonction Instance.new().

1. Créez un nouvel objet Folder en utilisant Instance.new("Folder"), en stockant le résultat dans une nouvelle variable appelée leaderstats.

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

2. Réglez la propriété Name de leaderstats sur "leaderstats".

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

Créer les points

Le système de leaderboard lit toutes les valeurs dans le dossier leaderstats et affiche tout ce qu'il trouve.

Pour ajouter une statistique qui suivra les points d'un joueur, un nouvel objet IntValue peut être parenté au dossier leaderstats. Le nom de l'objet de valeur sera affiché avec sa valeur actuelle.

1. Utilisez une variable nommée points pour créer un nouvel objet IntValue en utilisant Instance.new().
2. Réglez le Name sur "Points".
3. Réglez la Value sur 0 ; c'est ce que le leaderboard affichera initialement pour le joueur.
4. Parent l'objet points au dossier 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)

Testez votre expérience et vous devriez voir le leaderboard apparaître dans le coin supérieur droit avec les noms de vos utilisateurs et un score de points à côté d'eux.

Compter le temps

Chaque utilisateur devrait gagner un point pour chaque seconde qu'il est en vie. Une boucle while et la fonction task.wait() peuvent être utilisées pour mettre à jour la valeur des points chaque seconde.

1. À la fin du script, créez une boucle while avec true comme condition.
2. Dans la boucle, task.wait() pendant 1 seconde.

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Liste des joueurs

Pour exécuter du code pour chaque utilisateur dans l'expérience, vous devez itérer à travers le tableau d'utilisateurs retournés par la fonction GetPlayers.

Un tableau est une liste d'éléments stockés dans l'ordre. Chaque élément peut être accessible par sa position index, en commençant par 1. Vous pouvez obtenir la longueur d'un tableau en le préfixant avec #.

1. Stockez le résultat de Players:GetPlayers() dans une variable playerList.
2. Créez une boucle for avec une valeur de départ de 1 et une valeur de fin de #playerList, afin que vous obteniez une itération de la boucle par joueur.

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    -- Ajoutez votre logique ici pour chaque joueur dans le playerList
  end
end

Attribuer des points

Pour attribuer un point à chaque utilisateur dans la boucle for, vous devrez sortir l'utilisateur du tableau et ajouter 1 à l'objet Points stocké dans leur dossier leaderstats.

Les objets stockés dans un tableau sont accessibles en utilisant des crochets - par exemple, le premier élément du tableau playerList peut être accessible avec playerList[1]. Si vous écrivez playerList[currentPlayer] dans la boucle for, vous pouvez passer à chaque utilisateur de la liste à chaque itération de la boucle.

1. Stockez l'utilisateur à playerList[currentPlayer] dans une variable appelée player.
2. Stockez l'objet Points de l'utilisateur dans une variable appelée points.
3. Réglez la propriété Value de points sur 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

Testez votre expérience et vous devriez trouver que le leaderboard montre le score de votre joueur qui augmente de 1 chaque seconde.

Écouter les personnages

L'objectif de l'expérience est de voir qui peut rester en vie le plus longtemps, donc les utilisateurs qui meurent devront avoir leurs points réinitialisés à 0.

Vous devrez obtenir le modèle Character de l'utilisateur afin de détecter quand il est mort. Ce modèle n'est ajouté à l'expérience qu'après que l'objet Player a été chargé et vous pouvez utiliser l'événement CharacterAdded pour écouter quand le personnage est prêt à être utilisé. Créez une fonction appelée onCharacterAdded avec deux paramètres : un pour le personnage, un pour le joueur.

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

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

Bien que vous ayez inclus l'utilisateur dans les paramètres de la fonction onCharacterAdded, l'événement CharacterAdded ne retourne que le personnage, pas l'utilisateur associé. Pour passer l'objet player également, utilisez une fonction anonyme pour la connexion de l'événement.

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

Réinitialiser les points

Lorsque l'utilisateur meurt, son Humanoid déclenche automatiquement un événement Died. Vous pouvez utiliser cet événement pour savoir quand réinitialiser ses points.

Le Humanoid se trouve à l'intérieur du modèle Character, mais le contenu de ce modèle n'est assemblé que lorsque l'utilisateur apparaît. Pour faire en sorte que votre code attende en toute sécurité que l'objet Humanoid se charge, utilisez la fonction WaitForChild(). Vous pouvez l'appeler sur n'importe quel objet parent, en passant le nom de chaîne de l'enfant que vous attendez. Créez une variable pour attendre le Humanoid en utilisant character:WaitForChild("Humanoid").

local Players = game:GetService("Players")

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

La fonction que vous devez connecter à l'événement Died est très courte et ne sera nécessaire ici que, donc vous pouvez utiliser à nouveau une fonction anonyme.

1. Connectez une nouvelle fonction anonyme à l'événement Died du Humanoid.
2. Dans la fonction anonyme, créez une variable appelée points pour l'objet Points du joueur.
3. Réglez la propriété Value de points sur 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

Testez cela et vous verrez que le score de l'utilisateur se réinitialise lorsqu'il meurt.

Vérifier le joueur

Si les utilisateurs continuent à gagner des points même lorsqu'ils sont morts, cela ne correspond pas à l'esprit de l'expérience, il est donc nécessaire que le code vérifie si les utilisateurs sont en vie avant d'attribuer un point.

Vous devez commencer par définir un attribut dans la fonction onPlayerAdded qui peut être utilisé pour vérifier si l'utilisateur est en vie. À ce stade, l'utilisateur n'est pas encore vivant et_spawné_, car leur modèle de personnage doit encore être ajouté.

Les attributs vous permettent de personnaliser des objets dans Roblox avec vos propres données. Un attribut consiste en un nom et une valeur. Vous pouvez en créer un sur n'importe quel objet en utilisant la fonction SetAttribute. Appelez SetAttribute sur player pour créer un nouvel attribut appelé "IsAlive" avec la valeur 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

Une fois que le modèle de personnage de l'utilisateur réapparaît, la valeur de IsAlive doit être changée en true afin que l'utilisateur puisse recommencer à gagner des points.

1. Dans onCharacterAdded, réglez l'attribut IsAlive de player sur true.
2. Dans onCharacterDied, réglez l'attribut IsAlive de player sur 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

Enfin, IsAlive doit être vérifié avant qu'un point ne soit attribué dans la boucle while à la fin du script. La fonction GetAttribute prend le nom d'un attribut et retourne la valeur. Dans la boucle while, enveloppez le code pour attribuer un point dans une instruction if avec la condition 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

Testez votre expérience maintenant et vous devriez constater que l'utilisateur gagne des points chaque seconde qu'il est en vie, et reste à 0 lorsqu'il n'est pas en vie. Faites jouer vos connexions avec vous et voyez qui peut obtenir le meilleur score.

Ce n'est que le début : vous pouvez continuer à améliorer votre expérience pour vos utilisateurs. Voici quelques conseils :

• Placez le code pour toutes les plateformes dans un seul script, ce qui facilite beaucoup les mises à jour.
• Créez une zone de lobby où les utilisateurs attendent d'être téléportés vers la zone d'expérience, permettant aux utilisateurs de commencer simultanément.
• Annoncez les gagnants de chaque ronde.

Code 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