Boucles et tableaux

Tableaux peuvent être combinés avec des boucles, telles que while et for, pour répéter le même code pour chaque valeur indexée. Par exemple, téléporter chaque joueur dans un tableau vers un nouvel endroit ou faire en sorte qu'un tableau de pièces prenne feu.

Pour explorer la boucle à travers des tableaux, créez un chemin de pont qui disparaît où les pièces sont placées dans un tableau et ensuite faites-les disparaître une par une.

Boucle à travers un tableau

Pour le projet, trouvez ou créez un ensemble de trois pièces à faire disparaître. Les pièces doivent toutes être ancrées.

1. Créez trois pièces. Nommez les pièces dans l'ordre dans lequel elles doivent disparaître, Part1, Part2, Part3.

2. Dans ServerScriptService, insérez un nouveau script et créez un tableau pour stocker les pièces.

   local pathArray = {
   }

3. Sur une seule ligne chacune, tapez le nom des pièces dans l'ordre dans lequel elles doivent disparaître. Utiliser une nouvelle ligne pour chaque valeur facilite la lecture.

   local pathArray = {
   	workspace.Part1,
   	workspace.Part2,
   	workspace.Part3,
   }

Utilisez une boucle for avec un tableau

Utilisez une boucle for pour parcourir le tableau et contrôler la vitesse à laquelle les pièces doivent disparaître dans l'ordre dans lequel les pièces sont indexées dans le tableau.

1. Pour contrôler la fréquence à laquelle une pièce disparaît en secondes, créez une variable nommée VANISH_RATE. Pour les tests, il est préférable de la garder à un petit nombre.

   local VANISH_RATE = 1.5
   
   local pathArray = {
   	workspace.Part1,
   	workspace.Part2,
   	workspace.Part3
   }

   Constantes sont des variables qui ne devraient pas être modifiées par un autre code dans le script. Elles nécessiteront probablement des ajustements et sont placées en haut du script en ALL_CAPS pour les rendre faciles à repérer.

2. Créez une boucle for avec les éléments suivants : Début : partIndex = 1, l'index de la première valeur dans le tableau. Fin : #pathArray, la taille de ce tableau.

   for partIndex = 1, #pathArray  do
   
   end

3. Pour qu'il y ait un délai avant qu'une pièce disparaisse, dans la boucle, ajoutez un task.wait() en utilisant VANISH_RATE.

   for partIndex = 1, #pathArray  do
      task.wait(VANISH_RATE)
   end

4. Pour faire disparaître une pièce, créez une nouvelle variable nommée whichPart et définissez-la égale à partsArray[partIndex]. Ensuite, pour faire disparaître cette pièce, définissez sa propriété CanCollide sur false et Transparency sur 1.

   for partIndex = 1, #pathArray  do
      task.wait(VANISH_RATE)
      local whichPart = pathArray[partIndex]
      whichPart.CanCollide = false
      whichPart.Transparency = 1
   end

5. Vérifiez que les pièces du chemin disparaissent au fil du temps.

Conseils de dépannage

Si le pont ne disparaît pas, vérifiez les problèmes possibles ci-dessous :

Problème : Les pièces disparaissent trop vite ou sont toutes parties au début.

• En fonction de la rapidité avec laquelle votre personnage se charge dans le jeu, les premières pièces peuvent déjà être invisibles. Pour y remédier, ajoutez une petite attente, comme task.wait(2), au début du script.

Codez la deuxième boucle

Pour l'instant, les pièces disparaissent pour toujours. Pour les faire réapparaître, créez une deuxième boucle for qui parcourra chaque pièce et rendra instantanément chaque morceau praticable.

1. Après la première boucle, ajoutez un task.wait() pour créer un court délai avant que le chemin ne réapparaisse.

   for partIndex = 1, #pathArray  do
   	task.wait(VANISH_RATE)
   	local whichPart = pathArray[partIndex]
   	whichPart.CanCollide = false
   	whichPart.Transparency = 1
   end
   
   task.wait(1)

2. Par vous-même, essayez de coder une deuxième boucle for qui rend le chemin à nouveau utilisable en changeant la propriété CanCollide de chaque pièce à true et Transparency à 0. Une fois terminé, vérifiez votre travail par rapport au code ci-dessous.

   -- Réinitialiser le chemin en rendant toutes les pièces à nouveau praticables
   for partIndex = 1, #pathArray do
      local whichPart = pathArray[partIndex]
      whichPart.CanCollide = true
      whichPart.Transparency = 0
   end

   Les pièces non ancrées tomberont à travers la base lorsque CanCollide est false. Si les pièces ne réapparaissent pas, et qu'il n'y a pas d'erreurs dans la sortie, ancrez les pièces et testez à nouveau.

3. Testez le projet pour confirmer qu'une fois que toutes les pièces disparaissent, elles reviennent.

Répétez avec une boucle while

Les pièces disparaissent et réapparaissent, mais seulement une fois. Pour que le code continue à se répéter, imbriquez tout le code dans une boucle while.

1. En bas du script, créez une nouvelle boucle while true do. Ensuite, déplacez les deux boucles for dans la boucle while.

   while true do
      -- Faire disparaître une pièce du tableau dans l'ordre
   	for partIndex = 1, #pathArray  do
   		task.wait(VANISH_RATE)
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = false
   		whichPart.Transparency = 1
   	end
   
   	-- Attendre une seconde avant de faire réapparaître le chemin
   	task.wait(1)
   
   	-- Réinitialiser le chemin en rendant toutes les pièces à nouveau praticables
   	for partIndex = 1, #pathArray do
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = true
   		whichPart.Transparency = 0
   	end
   end

2. Vérifiez qu'une fois que toutes les pièces disparaissent, elles réapparaissent.

Une version terminée du projet peut être téléchargée.

local VANISH_RATE = 1.0

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

while true do
	-- Faire disparaître une pièce du tableau dans l'ordre
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Attendre une seconde avant de faire réapparaître le chemin
	task.wait(1.0)

	-- Réinitialiser le chemin en rendant toutes les pièces à nouveau praticables
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Tableaux et ipairs()

ipairs() est utilisé avec tableaux. Le "i" dans ipairs() signifie "index". ipairs() peut être utilisé pour répéter rapidement une opération sur un grand nombre d'objets, comme, par exemple, un dossier plein de pièces.

Cela sera démontré en ajoutant rapidement des particules à un dossier entier de pièces.

1. Dans Workspace, créez un dossier nommé PartsFolder. Ajoutez autant de pièces que vous le souhaitez.

2. Dans ServerScriptService, créez un nouveau script et référencez le dossier.

3. Utilisez GetChildren() pour obtenir automatiquement un tableau répertoriant tous les objets dans le dossier.

   local partsFolder = workspace.PartsFolder
   
   -- Obtient un tableau répertoriant les pièces dans PartsFolder
   local partsArray = partsFolder:GetChildren()

4. Utilisez in ipairs(ArrayToUse) avec la boucle for pour parcourir partsArray et ajouter des particules.

   Script complété

   -- Obtient un tableau répertoriant les pièces dans PartsFolder
   local partsArray = partsFolder:GetChildren()
   
   -- Ajoute des particules à chaque pièce dans le tableau
   for index, part in ipairs(partsArray) do
   	local particles = Instance.new("ParticleEmitter")
   	particles.Parent = part
   end

Testez et regardez les particules s'élever de chaque pièce dans le dossier.

Résumé

Les boucles peuvent être combinées avec des tableaux pour travailler rapidement avec n'importe quel nombre de valeurs. Si vous souhaitez avoir un contrôle exact sur ce qui arrive à quelques pièces et dans quel ordre, un tableau doit être codé en dur avec des valeurs spécifiques.

Pour travailler avec de nombreuses pièces où l'ordre n'a pas d'importance, GetChildren() peut créer un tableau des enfants d'un objet. En utilisant ipairs(), la liste peut être rapidement itérée sans connaître la taille du tableau.