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 transparentes et de la lave mortelle. Ce tutoriel les relie 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 transparentes que vous avez créées dans le tutoriel précédent et laissez les utilisateurs concourir pour rester sur le plateau de plateformes aussi longtemps que possible.

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

Points des joueurs

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

Vous apprendrez plus de moyens personnalisables pour afficher des informations dans des tutoriels ultérieurs, mais le tableau de bord est le moyen le plus simple de créer un système de scoring visible dans Roblox.

Il est préférable de mettre les scripts qui configurent l'état de l'expérience dans ServerScriptService car ils seront exécutés automatiquement lorsque l'expérience démarre. 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 partout 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 apparaître les points d'un utilisateur dans le tableau de bord, tout ce que vous avez à faire est de créer un nouveau Folder dans l'objet Player appelé "leaderstats" et d'y placer 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. Définissez la propriété Name de leaderstats sur "leaderstats".

3. Ajoutez leaderstats comme enfant 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)

Créer les points

Le système de tableau de bord 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é à côté de sa valeur actuelle.

1. Utilisez une variable nommée points pour créer un nouvel objet IntValue en utilisant Instance.new().
2. Définissez le Name sur "Points".
3. Définissez le Value sur 0; c'est ce que le tableau de bord affichera initialement pour le joueur.
4. Ajoutez 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 tableau de bord apparaître en haut à droite 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 des utilisateurs retourné par la fonction GetPlayers.

Un tableau est une liste d'éléments stockés dans un certain ordre. Chaque élément peut être accédé par sa position d'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 d'obtenir 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 playerList
  end
end

Attribuer des points

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

Les objets stockés dans un tableau sont accessibles à l'aide de crochets - par exemple, le premier élément du tableau playerList peut être accédé avec playerList[1]. Si vous écrivez playerList[currentPlayer] dans la boucle for, vous pouvez parcourir 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. Définissez 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 constater que le tableau de bord 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 pour l'utilisateur afin de détecter quand ils sont morts. Ce modèle n'est ajouté à l'expérience qu'après le chargement de l'objet Player 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 à 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

Lorsqu'un 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 soit chargé, utilisez la fonction WaitForChild(). Vous pouvez l'appeler sur n'importe quel objet parent, en passant le nom de chaîne de l'enfant pour lequel 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 jamais nécessaire ailleurs, donc vous pouvez à nouveau utiliser 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. Définissez la propriété Value de points à 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, ce n'est pas du tout dans l'esprit de l'expérience, donc le code doit vérifier si les utilisateurs sont vivants 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 vivant. À ce stade, l'utilisateur n'est pas encore vivant et spawn, car son modèle de personnage doit encore être ajouté.

Les attributs vous permettent de personnaliser les objets dans Roblox avec vos propres données. Un attribut se compose d'un nom et d'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 respawn, la valeur de IsAlive doit être changée en true afin que l'utilisateur puisse commencer à gagner des points à nouveau.

1. Dans onCharacterAdded, définissez l'attribut IsAlive de player sur true.
2. Dans onCharacterDied, définissez 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 soit attribué dans la boucle while à la fin du script. La fonction GetAttribute prend le nom d'un attribut et renvoie 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 découvrir que l'utilisateur gagne des points chaque seconde qu'il est vivant et reste à 0 lorsqu'il n'est pas vivant. Demandez à vos amis de jouer 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 rend beaucoup plus facile les mises à jour.
• Créez une zone d'attente où les utilisateurs attendent d'être téléportés à la zone d'expérience, permettant aux utilisateurs de commencer simultanément.
• Annoncez les gagnants de chaque manche.

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