Marquer des points

Dans les tutoriels précédents, vous avez créé une variété de fonctionnalités de jeu, y compris des plateformes qui s'estompent et de la lave mortelle. Ce tutoriel les relie dans un jeu 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 devez préparer la scène pour votre jeu. Dupliquez les plateformes qui s'estompent que vous avez créées dans le tutoriel précédent et laissez les utilisateurs rivaliser pour rester sur le plateau de plateformes aussi longtemps que possible.

Vous pouvez également utiliser de la lave mortelle pour tuer les utilisateurs lorsqu'ils tombent des plateformes, ou simplement les laisser tomber vers 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 dispose d'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 le jeu.

Vous apprendrez des moyens plus personnalisables d'afficher des informations dans des tutoriels ultérieurs, mais le leaderboard est la manière la plus simple de créer un système de score visible dans Roblox.

Il est préférable de placer les scripts qui configurent l'état du jeu dans ServerScriptService car ils s'exécuteront automatiquement lorsque le jeu 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 le jeu.

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 jeu.

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. Définissez la propriété Name de leaderstats sur "leaderstats".

3. Parent leaderstats à 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é à 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 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 jeu et vous devriez voir le leaderboard 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 le jeu, vous devez itérer à travers le tableau d'utilisateurs renvoyé par la fonction GetPlayers.

Un tableau est une liste d'éléments stockés dans l'ordre. Chaque élément peut être accédé 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 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 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 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 jeu et vous devriez constater que le leaderboard montre le score de votre joueur augmentant de 1 chaque seconde.

Écouter les personnages

L'objectif du jeu 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 il est mort. Ce modèle n'est ajouté au jeu 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 renvoie 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 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 jamais nécessaire ailleurs, donc vous pouvez utiliser une fonction anonyme à nouveau.

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 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 du jeu, donc le code doit vérifier 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 en vie et n'est pas encore apparu, car son 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 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 recommencer à gagner des points.

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 ne 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 jeu 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 amis avec vous et voyez qui peut obtenir le score le plus élevé.

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

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

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