Boucles et tableaux

Les tableaux peuvent être combinés avec des boucles, comme 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 à un nouvel endroit ou faire en sorte qu'un tableau de parties prenne lancer.

Pour explorer la boucle à travers les tableaux, créez un chemin de pont disparaissant où les parties sont placées dans un tableau et sont ensuite faites disparaître une par une.

Boucle à travers un matrice

Pour le projet, trouvez ou créez un ensemble de trois parties pour disparaître. Les parties doivent toutes être ancrées.

Créez trois parties. Nommez les parties dans l'ordre dans lequel elles devraient disparaître, Part1, Part2, Part3.
Dans ServerScriptService, insérez un nouveau script et créez un tableau pour stocker les parties.
```
local pathArray = {
}
```

Sur une seule ligne à la fois, saisissez le nom des parties dans l'ordre dans lequel elles devraient disparaître. L'utilisation d'une nouvelle ligne pour chaque valeur facilite la lu.


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

Utiliser une boucle for avec un matrice

Utilisez une boucle for pour parcourir l'array et contrôler la vitesse à laquelle les parties doivent disparaître dans l'ordre dans lequel elles sont indexées dans l'matrice.

Pour contrôler la fréquence à laquelle une partie disparaît en secondes, créez une variable nommée VANISH_RATE . Pour le test, il est préférable de la garder à un petit nombre.
```
local VANISH_RATE = 1.5

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Les constantes sont des variables qui ne devraient pas être modifiées par tout autre code dans le script.Ils sont susceptibles de nécessiter une ajusture et sont placés en haut du script dans ALL_CAPS pour les rendre faciles à repérer.
Créez une boucle for avec ce qui suivre: Commencer : partIndex = 1 , l'index du premier valeur dans l'matrice. Fin : #pathArray, la taille de cet matrice.
```
for partIndex = 1, #pathArray  do

end
```

Il y a donc un délai avant que une partie disparaisse, dans la boucle, ajoutez un task.wait() utilisant VANISH_RATE .


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

Pour faire disparaître une partie, créez une nouvelle variable nommée whichPart et définissez-la à l'égal de partsArray[partIndex].Ensuite, pour disparaître cette partie, définissez sa propriété CanCollide à false et Transparency à 1.


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

Vérifiez que des parties du chemin disparaissent au fil du temps.

Conseils de dépannage

Si le pont n'a pas disparu, vérifiez les problèmes possibles ci-dessous : Problème : Les pièces disparaissent trop rapidement ou sont toutes parties au commencer.

En fonction de la vitesse à laquelle votre personnage se charge dans l'expérience, les premières parties 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

En ce moment, les parties disparaissent pour toujours.Pour les faire réapparaître, créez une boucle de deuxième génération qui parcourra chaque partie et rendra chaque pièce immédiatement marchable.

Après la première boucle, ajoutez un task.wait() pour créer un court délai avant que le chemin 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)

Sur votre propre , essayez de coder une deuxième boucle qui rend le chemin à nouveau utilisable en changeant la propriété CanCollide de chaque partie en vrai et la transparence en 0.Une fois terminé, vérifiez votre travail contre le code ci-dessous.


-- Réinitialisez le chemin en rendant toutes les parties à nouveau accessibles
for partIndex = 1, #pathArray do
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = true
   whichPart.Transparency = 0
end

Les parties non ancrées tomberont à travers la plaque de base lorsque CanCollide est faux.Si les parties ne réapparaissent pas et qu'il n'y a pas d'erreurs de sortie, ancrez les parties et testez à nouveau.

Testez le projet pour confirmer que une fois toutes les parties disparues, elles retour.

Répéter avec une boucle while

Les parties disparaissent et réapparaissent, mais seulement une fois. Pour que le code se répète sans cesse, imbriquez tout le code dans une boucle while.

En bas du script, créez une nouvelle boucle while vraie. Puis, déplacez les deux pour les boucles dans la boucle while.


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

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

	-- Réinitialisez le chemin en rendant toutes les parties à nouveau accessibles
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Vérifiez que une fois toutes les parties disparues, elles réapparaissent.

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

Script script
local VANISH_RATE = 1.0

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

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

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

	-- Réinitialisez le chemin en rendant toutes les parties à nouveau accessibles
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Tableaux et ipairs()

ipairs() est utilisé avec arrays .Le "i" dans ipairs() signifie "index." ipairs() peut être utilisé pour répéter rapidement une opération sur beaucoup d'objets, comme, disons, un dossier rempli de pièces.

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

Dans l'espace de Workspace, créez un dossier nommé PartsFolder. Ajoutez autant de pièces que vous le souhaitez.
Dans ServerScriptService, créez un nouveau script et référencez le dossier.

Utilisez GetChildren() pour obtenir automatiquement une liste d'objets dans le dossier.


local partsFolder = workspace.PartsFolder

-- Obtient une liste d'arrangements dans le dossier PartsFolder
local partsArray = partsFolder:GetChildren()

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

Script script
-- Obtient une liste d'arrangements dans le dossier PartsFolder
local partsArray = partsFolder:GetChildren()

-- Ajoute des particules à chaque partie de l'matrice
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

Testez et observez les particules flotter de chaque partie dans le dossier.

Sommaire

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

Pour travailler avec de nombreuses parties 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 itérée rapidement sans connaître la taille de l'matrice.