Points deScore | Documentation - Hub Création Roblox

Dans les tutoriels précédents, vous avez fait une variété de fonctionnalités d'expérience, y compris plates-formes fugaces et lave mortelle. Ce tutoriel lie 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.

Mise en place

Tout d'abord, vous devrez configurer la scène pour votre expérience. Dupliquez les plates-formes fading que vous avez créées dans le tutoriel précédent et laissez les utilisateurs concurrencer pour rester sur le tableau des plates-formes aussi longtemps que possible.

Vous pouvez également utiliser lave mortelle pour tuer les utilisateurs lorsqu'ils tombent des plates-formes, ou simplement les laisser tomber jusqu'à leur mort. Assurez-vous de placer un Lieu d'apparition quelque part où les utilisateurs peuvent sauter sur les plates-formes pour commencer à jouer.

Points du joueur

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

Leaderboard with username and points shown

Vous en apprendrez plus de manières personnalisables de montrer l'information dans les tutoriels ultérieurs, mais le classement est le moyen le plus simple de faire un système de classement visible dans Roblox.

Il est préférable de mettre des scripts qui définissent l'état de l'expérience dans ServerScriptService parce qu'ils s'exécuteront automatiquement lorsque l'expérience démarre. Dans ServerScriptService , créez un script nommé SetupPoints .

SetupPoints script in place in ServerScriptService in the Explorer window

É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 des 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 n'importe où qui contient tout dans votre expérience.

Créez une variable pour le service Joueurs en utilisant game:GetService("Players").
Créer une fonction nommée onPlayerAdded avec un paramètre pour le joueur entrant.

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


local Players = game:GetService("Players")

local function onPlayerAdded(player)

end

Players.PlayerAdded:Connect(onPlayerAdded)

Lorsque vous déclarez une variable pour contenir un service, il est préférable de le nommer avec le nom exact du service ( "Players" ) même si cela signifie briser les normes de nommage habituelles pour les variables.

Créer un dossier statistique

Pour faire en sorte que les points d'un utilisateur apparaissent dans le classements, tout ce que vous avez à faire est de créer un nouveau Folder dans leur objet Player nommé "leaderstats" et de mettre leurs points là-dedans. Les nouveaux objets peuvent être créés à partir d'un script via la fonction 1> Datatype.Instance.new()1>.

Créer un nouveau Folder objet en utilisant Instance.new("Folder") , en stockant le résultat dans une nouvelle variable nommée leaderstats .


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

Définir la propriété Nom de leaderstats à "leaderstats" .

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)

Assurez-vous de renommer le dossier exactement comme il est affiché ici ( "leaderstats" ) ou il ne fonctionnera pas !

Créer les points

Le système de classement lit tous les valeurs dans le leaderstats dossier et affiche ce que il trouve.

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

Utilisez une variable nommée points pour créer un nouveau objet IntValue à l'aide de Instance.new() .
Définir le Name sur "Points".
Définissez le Value sur 0 ; c'est ce que le classement affichera initialement pour le joueur.
Parent l'objet points à l'arboire.


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 classement 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 vivant. Un while boucle et la fonction task.wait() peuvent être utilisés pour mettre à jour la valeur des points chaque seconde.

À la fin du script, créez un while boucle avec true comme condition.
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és par la fonction GetPlayers.

Un tableau est une liste d'objets stockés en ordre. Chaque objet peut être accédé par sa position index , à partir de 1. Vous pouvez obtenir la longueur d'un tableau en la préfixant avec #.

Stockez le résultat de Players:GetPlayers() dans une variable playerList.
Créez un pour boucle avec une valeur de départ de 1 et une valeur de fin de #playerList afin que vous obteniez un itération du 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 la liste des joueurs
  end
end

Attribution de points

Pour attribuer un point à chaque utilisateur dans le for loop, vous devrez faire sortir l'utilisateur de l' array et ajouter 1 à l'objet Points stocké dans leur dossier leaderstats.

Les objets stockés dans un tableau sont accédés à l'aide de crochets carrés - par instance, le premier élément de l'arrêt playerList peut être accédé avec playerList[1]. Si vous écrivez 2>playerList[currentPlayer]2> dans le for loop, vous pouvez déplacer chaque utilisateur dans la liste avec chaque itération du for loop.

Store the user at playerList[currentPlayer] in a variable called player .
Stockez l'objet Points de l'utilisateur dans une variable appelée points .
Définir la propriété Value de points à 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 classement montre le score de votre joueur compter par 1 chaque seconde.

Écoute des caractères

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

Vous devrez obtenir le modèle Personnage pour l'utilisateur afin de détecter quand ils sont morts. Ce modèle n'est ajouté qu'à l'expérience après que l'objet Class.Player soit chargé et vous pouvez utiliser l'événement Class.Player.CharacterAdded|CharacterAdded


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 actuel ne renvoie que le personnage, pas l'utilisateur associé. Pour transmettre l'objet player de manière aussi vraie, 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éinitialisation des points

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

Le Humanoid est trouvé à l'intérieur du modèlisationCharacter, mais les contenus de ce modèle ne sont récupérés que lorsque l'utilisateur apparaît. Pour rendre votre code en sécurité en attendant que l'objet Humanoid se charger, utilisez la fonction WaitForChild(). Vous pouvez l'appeler sur n'importe quel parent objet, en passant le nom de la


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 ici, vous pouvez donc utiliser une fonction anonyme à nouveau.

Connectez une nouvelle fonction anonyme à l'événement mort du Humanoid.
Dans la fonction anonyme, créez une variable nommée points pour l'objet Points du joueur.
Définir 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 ceci et vous verrez le score de l'utilisateur se réinitialiser lorsqu'il meurt.

Vérification du joueur

Si les utilisateurs continuent à gagner des points même morts, il n'est pas du tout dans l'esprit de l'expérience, il faut donc vérifier si les utilisateurs sont vivants avant de leur attribuer un point.

Vous devez commencer en définissant une fonction onPlayerAdded qui peut être utilisée pour vérifier si l'utilisateur est vivant. À ce stade, l'utilisateur n'est pas encore vivant et n'a pas encore été généré, car le modèle de leur personnage doit encore être ajouté.

Les attributs vous permettent de personnaliser les 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. Applez Class.Instance:SetAttribute()


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 modifiée en true afin que l'utilisateur puisse à nouveau gagner des points.

Dans onCharacterAdded, définissez l'attribut IsAlive de player sur 1> vrai1> .
En onCharacterDied, définissez l'attribut IsAlive de player sur 1> faux1> .


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 devrait être vérifié avant que tout point ne soit attribué dans le while boucle à la fin du script. La fonction 1> Class.Instance:GetAttribute()|GetAttribute1> prend le nom


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 trouver que l'utilisateur gagne des points chaque seconde qu'il est en vie, et reste à 0 quand il n'est pas en vie. Invitez vos amis à jouer avec vous et voyez qui peut obtenir le score le plus élevé.

Ceci est juste le commencer: vous pouvez continuer à améliorer votre expérience pour vos utilisateurs. Voici quelques conseils :

Placez le code pour toutes les plates-formes dans un seul script, ce qui facilite grandement la mise à jour.
Créez une zone de lobby où les utilisateurs attendent d'être téléportés dans la zone d'expérience, ce qui permet aux utilisateurs de commencer simultanément.
Annoncez les gagnants de chaque tour.

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