Pratique avec else/if pour attribuer des points | Documentation

Ce projet utilisera des instructions conditionnelles pour créer une partie qui attribuera ou retirera des points sur un tableau des leaders selon la couleur de la partie lorsqu'elle est touchée. Si c'est bleu, alors cela donnera quelques points aux joueurs. Si c'est vert, alors cela donnera beaucoup de points. Enfin, si c'est rouge, alors cela retirera des points.

Configurer le projet

La partie attribuant des points peut être ajoutée à n'importe quel projet où les points sont pertinents. Par exemple, un jeu d'aventure où les joueurs collectent des points.

Suivi des points

Pour configurer ce projet, vous aurez besoin d'un tableau des leaders pour suivre les points et d'une partie qui change de couleur. Le code pour le tableau des leaders sera fourni.

Créez un nouveau script dans ServerScriptService nommé Leaderboard. Copiez et collez le code ci-dessous dans le script.


--Dans ServerScriptService, créez un script nommé PlayerSetup avec le contenu ci-dessous.

local Players = game:GetService("Players")

local function onPlayerJoin(player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"
	leaderstats.Parent = player

	-- Exemple d'un IntValue
	local points = Instance.new("IntValue")
	points.Name = "Points"
	points.Value = 0
	points.Parent = leaderstats
end

-- Exécuter onPlayerJoin lorsque l'événement PlayerAdded est déclenché
Players.PlayerAdded:Connect(onPlayerJoin)

Partie changeant de couleur

Le script fera défiler trois couleurs différentes pour la partie. Chaque couleur aura une variable pour stocker sa valeur RGB, un type de donnée qui inclut un ensemble de trois nombres (rouge, vert, bleu) qui créent des couleurs.

Créez une partie nommée PointPart avec un script attaché nommé PointScript.

Dans PointScript, utilisez script.Parent pour faire référence à la partie.


local pointPart = script.Parent

Créez des variables pour stocker les différentes couleurs. Chaque variable doit être définie sur Color3.fromRGB(), qui crée une valeur de couleur.

Bleu (Quelques points) : (0, 0, 255)
Vert (Beaucoup de points) : (0, 255, 0)
Rouge (Perdre des points) : (255, 0, 0)


local pointPart = script.Parent

-- Couleurs
local blue = Color3.fromRGB(0, 0, 255)
local green = Color3.fromRGB(0, 255, 0)
local red = Color3.fromRGB(255, 0, 0)

Ajoutez des variables pour une petite quantité de points, une plus grande quantité de points, et une troisième pour retirer des points.


-- Couleurs
local blue = Color3.fromRGB(0, 0, 255)
local green = Color3.fromRGB(0, 255, 0)
local red = Color3.fromRGB(255, 0, 0)

-- Valeurs des points
local smallPoints = 10
local largePoints = 50
local losePoints = 100

Ajouter le service des joueurs

Pour attribuer des points, vous devrez accéder aux informations du joueur qui sont stockées dans l'Explorateur sous Joueurs, et qui sont séparées de l'objet de personnage. C'est ici que des informations telles que les statistiques du tableau des leaders peuvent être trouvées.

Vous pouvez le faire en ajoutant le service Players à votre script. Les Services sont des ensembles supplémentaires de fonctions pré-construites créées par les ingénieurs Roblox pour vous faire gagner du temps.

Obtenez le service Players en tapant :

local Players = game:GetService("Players")


-- Valeurs des points
local smallPoints = 10
local largePoints = 50
local losePoints = 100

-- Services nécessaires
local Players = game:GetService("Players")

Fonctions et événements

PointsScript aura besoin de deux fonctions. La première fonction attribuera et déduira des points. La seconde fonction vérifiera si un joueur a touché la partie. Ces fonctions seront ensuite connectées à un événement de toucher, qui s'exécute chaque fois que cette partie est touchée.

Créez une nouvelle fonction nommée givePoints() et un paramètre nommé player. À l'intérieur, ajoutez une instruction d'impression à utiliser pour les tests.


local Players = game:GetService("Players")

-- Donne ou soustrait des points
local function givePoints(player)
	print("Attribution de points au joueur")
end

Sous cela, créez une seconde fonction nommée partTouched() avec un paramètre nommé otherPart.


-- Donne ou soustrait des points
local function givePoints(player)
	print("Attribution de points au joueur")
end

-- Vérifie si le joueur a touché la partie
local function partTouched(otherPart)

end

À l'intérieur de la fonction, utilisez la fonction GetPlayerFromCharacter() pour vérifier s'il y a un joueur dans la variable otherPart.


-- Vérifie si le joueur a touché la partie
local function partTouched(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
end

Si un joueur a touché la partie, il sera stocké dans la variable player. Sinon, la variable restera vide. Par vous-même :

À l'intérieur de la fonction, vérifiez si player a une valeur. S'il y en a une, alors appelez givePoints(player).
Sous la fonction, connectez partTouched() à l'événement Touched de pointPart.


-- Vérifie si le joueur a touché la partie
local function partTouched(otherPart)
	-- Obtient le joueur si l'un a touché la partie
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

Exécutez le projet. Chaque fois qu'un joueur touche la partie, vous devriez voir un message dans la fenêtre de sortie disant : "Attribution de points au joueur"

Conseils de dépannage :

Vérifiez que "Players" dans game:GetService("Players") est en majuscules et entre guillemets.
partTouched() doit être connecté à l'événement Touched de pointPart.

Créer des couleurs en boucle

Pour faire défiler les couleurs, le script utilisera une boucle while =loop qui change la couleur de la partie toutes les quelques secondes. La condition pour cette boucle sera vraie, elle pourra donc s'exécuter indéfiniment.

À la fin du script, créez une nouvelle boucle while où la condition est vraie, ce qui signifie que la boucle s'exécute toujours.


-- Vérifie si le joueur a touché la partie
local function partTouched(otherPart)
	-- Obtient le joueur si l'un a touché la partie
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)
	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

-- Fait défiler les couleurs
while true do

end

Si la boucle while true do n'est pas en bas du script, tout code en dessous ne sera jamais exécuté. Comme la boucle while ne s'arrête pas, elle continuera d'exécuter la boucle au lieu de tout code ci-dessous.

Par vous-même, codez une boucle while true do qui change pointPart aux variables de couleur que vous avez créées. N'oubliez pas d'utiliser task.wait() entre les couleurs. Lorsque vous avez terminé, vérifiez votre code avec la version ci-dessous.


-- Fait défiler 3 couleurs, en attendant entre chaque couleur
while true do
	pointPart.Color = blue
	task.wait(3)
	pointPart.Color = green
	task.wait(2)
	pointPart.Color = red
	task.wait(1)
end

Testez en jouant et vérifiez que les trois couleurs se répètent sans interruption.

Conseils de dépannage

À ce stade, si le défilement des couleurs ne fonctionne pas comme prévu, essayez l'une des options ci-dessous.

Vérifiez que la boucle while est en bas du script, sous l'événement Touched. Si la boucle n'est pas en bas, cela empêchera d'autres parties du script de fonctionner correctement.
Vérifiez que chaque couleur à l'intérieur de Color3.fromRGB() est correctement écrite. Il doit y avoir trois nombres entre 0 et 255 séparés par des virgules, comme (255, 50, 0).

Donner des points aux joueurs

Les joueurs recevront des points en fonction de la couleur actuelle de la partie lorsqu'ils la toucheront.

Trouver la couleur actuelle

Chaque fois qu'un joueur touche la partie, le script devra connaître la couleur actuelle de la partie pour attribuer des points plus tard.

Trouvez givePoints(). Remplacez votre message de test par une variable pour la couleur actuelle de pointPart. Cette variable déterminera combien de points le joueur obtient (ou perd).


local function givePoints(player)
	local currentColor = pointPart.Color
end

Pour affecter les points d'un joueur, cette fonction doit avoir accès au tableau des leaders du joueur. Créez une variable pour le stocker.


local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
end

Ajoutez maintenant une variable pour obtenir la valeur des Points du joueur, qui est un enfant de son tableau des leaders.


local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
	local playerPoints = playerStats:WaitForChild("Points")
end

Donner ou soustraire des points

Ensuite, vous utiliserez if et elseif pour donner ou soustraire des points selon la couleur de la partie lors de son toucher. Rappelez-vous que bleu fournit une petite quantité, vert fournit beaucoup, et rouge soustrait des points.

À l'intérieur de givePoints(), sous les variables, utilisez une instruction if pour vérifier si la couleur actuelle est bleue et si oui, ajoutez smallPoints à la valeur actuelle des points du joueur.


local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
	local playerPoints = playerStats:WaitForChild("Points")

	if currentColor == blue then
		playerPoints.Value += smallPoints
	end
end

Pour vérifier la couleur verte, ajoutez une condition else if. Si c'est vert, alors ajoutez la variable largePoints aux points du joueur.


if currentColor == blue then
	playerPoints.Value += smallPoints
elseif currentColor == green then
	playerPoints.Value += largePoints
end

Utilisez une instruction else pour soustraire des points si pointsPart n'était ni bleu ni vert.


if currentColor == blue then
	playerPoints.Value += smallPoints
elseif currentColor == green then
	playerPoints.Value += largePoints
else
	playerPoints.Value -= losePoints
end

Enfin, détruisez la partie après l'instruction if afin que le script ne puisse pas continuer à attribuer des points.


if currentColor == blue then
	playerPoints.Value += smallPoints
elseif currentColor == green then
	playerPoints.Value += largePoints
else
	playerPoints.Value -= losePoints
end

pointPart:Destroy()

Testez le jeu et vérifiez que chaque couleur attribue des points comme prévu. Assurez-vous de tester les trois conditions.

Donner un retour aux joueurs

La PointPart fonctionne, mais les joueurs pourraient ne pas remarquer qu'un événement s'est produit à moins qu'ils ne regardent leur tableau des leaders. Corrigez cela en créant des particules lorsque la PointPart est détruite.

Ajouter un retour lorsqu'un joueur utilise une partie, comme des sons, des tremblements ou des particules, rend les interactions avec les objets plus satisfaisantes pour les joueurs.

Créer un effet de particules

L'effet de particules sera de la même couleur que la partie lorsqu'elle est touchée. Étant donné que les couleurs étaient stockées dans des variables, il est facile de les réutiliser.

Dans givePoints() en bas, créez une nouvelle instance ParticleEmitter. Assurez-vous que le nom de l'instance est correctement orthographié comme montré.


local particle = Instance.new("ParticleEmitter")
end

Les ParticleEmitters utilisent des séquences de couleurs pour contrôler leur propriété Color. Créez une nouvelle ColorSequence et passez la couleur actuelle de la partie.


-- Détruire la partie
pointPart:Destroy()

-- Créer des particules
local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

La particule devra être parentée au joueur qui l'a touchée. Créez une variable pour obtenir le modèle de personnage du joueur. Ensuite, parenthez la particule à la tête du joueur.


local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

local playerCharacter = player.Character
particle.Parent = playerCharacter:WaitForChild("Head")

Utilisez task.wait() pendant une seconde, puis détruisez les particules.


local particle = Instance.new("ParticleEmitter")
particle.Color = ColorSequence.new(currentColor)

local playerCharacter = player.Character
particle.Parent = playerCharacter:WaitForChild("Head")

task.wait(1)
particle:Destroy()

Testez le jeu et assurez-vous que les particules suivent brièvement le joueur après avoir touché chaque couleur.

Conseils de dépannage

À ce stade, si les particules ne fonctionnent pas comme prévu, essayez l'une des options ci-dessous.

Assurez-vous que lorsque vous créez une nouvelle instance, ParticleEmitter est orthographié exactement comme montré et à l'intérieur de guillemets.
Lorsque vous parenthez les particules, assurez-vous d'utiliser : entre playerCharacter et WaitForChild() sans espaces entre.

PointScript complet

Une version terminée du script peut être référencée ci-dessous.


local pointPart = script.Parent
--local storage = game:GetService("ServerStorage")

-- Donne quelques points
local blue = Color3.fromRGB(0, 0, 255)
-- Donne plus de points
local green = Color3.fromRGB(0, 255, 0)
-- Fait perdre des points aux joueurs
local red = Color3.fromRGB(255, 0, 0)

-- points donnés aux joueurs
local smallPoints = 10
local largePoints = 50
local losePoints = 100

local Players = game:GetService("Players")

local function givePoints(player)
	local currentColor = pointPart.Color

	local playerStats = player:WaitForChild("leaderstats")
	local playerPoints = playerStats:WaitForChild("Points")

	-- Donne des points au joueur en fonction de la couleur de la partie
	if currentColor == blue then
		playerPoints.Value += smallPoints
	elseif currentColor == green then
		playerPoints.Value += largePoints
	else
		playerPoints.Value -= losePoints
	end

	-- Détruit la partie, attend une seconde, puis détruit la particule
	pointPart:Destroy()

	-- Crée un effet de scintillement et le détruit
	local playerCharacter = player.Character
	local particle = Instance.new("ParticleEmitter")
	particle.Color = ColorSequence.new(currentColor)
	particle.Parent = playerCharacter:WaitForChild("Head")
	task.wait(1)
	particle:Destroy()
end

local function partTouched(otherPart)
	local player = Players:GetPlayerFromCharacter(otherPart.Parent)

	if player then
		givePoints(player)
	end
end

pointPart.Touched:Connect(partTouched)

-- Change la couleur de la partie en fonction des variables. Doit être en bas du script.
while true do
	pointPart.Color = blue
	task.wait(4)
	pointPart.Color = green
	task.wait(3)
	pointPart.Color = red
	task.wait(2)
end